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

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -18,35 +18,12 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 
 	visitColumn({ entity, column }: Model.ColumnContext): void {
 		const columnPath = this.executionContext.path
-		this.executionContext.addColumn(qb => {
-			const tableAlias = columnPath.back().alias
-			const columnAlias = columnPath.alias
+		const tableAlias = columnPath.back().alias
+		const columnAlias = columnPath.alias
 
-			const fieldPredicate = this.predicateFactory.shouldApplyCellLevelPredicate(
-				entity,
-				Acl.Operation.read,
-				column.name,
-			)
-				? this.predicateFactory.create(entity, Acl.Operation.read, [column.name])
-				: undefined
-
-			if (!fieldPredicate || Object.keys(fieldPredicate).length === 0) {
-				return qb.select([tableAlias, column.columnName], columnAlias)
-			}
-			return this.whereBuilder.buildAdvanced(entity, columnPath.back(), fieldPredicate, cb =>
-				qb.select(
-					expr =>
-						expr.case(caseExpr =>
-							caseExpr
-								.when(
-									whenExpr => whenExpr.selectCondition(cb),
-									thenExpr => thenExpr.select([tableAlias, column.columnName]),
-								)
-								.else(elseExpr => elseExpr.raw('null')),
-						),
-					columnAlias,
-				),
-			)
+		this.executionContext.addColumn({
+			query: qb => qb.select([tableAlias, column.columnName], columnAlias),
+			predicate: this.getRequiredPredicate(entity, column),
 		})
 	}
 
@@ -55,20 +32,19 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		if (!field) {
 			throw new Error()
 		}
-		this.executionContext.addData(
-			relationContext.entity.primary,
-			async ids =>
-				this.relationFetcher.fetchManyHasManyGroups(
-					{
-						mapper: this.mapper,
-						field: field,
-						relationContext,
-						relationPath: this.relationPath,
-						ids: ids,
-					},
-				),
-			[],
-		)
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
+				this.relationFetcher.fetchManyHasManyGroups({
+					mapper: this.mapper,
+					field: field,
+					relationContext,
+					relationPath: this.relationPath,
+					ids: ids,
+				}),
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext): void {
@@ -77,9 +53,9 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 			throw new Error()
 		}
 
-		this.executionContext.addData(
-			relationContext.entity.primary,
-			async ids =>
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
 				this.relationFetcher.fetchManyHasManyGroups({
 					mapper: this.mapper,
 					field: field,
@@ -87,8 +63,9 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationPath: this.relationPath,
 					ids: ids,
 				}),
-			[],
-		)
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitOneHasMany(relationContext: Model.OneHasManyContext): void {
@@ -97,9 +74,9 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 			throw new Error()
 		}
 
-		this.executionContext.addData(
-			relationContext.entity.primary,
-			async ids =>
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
 				this.relationFetcher.fetchOneHasManyGroups({
 					mapper: this.mapper,
 					objectNode: field,
@@ -107,15 +84,16 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationPath: this.relationPath,
 					ids: ids,
 				}),
-			[],
-		)
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitOneHasOneInverse(relationContext: Model.OneHasOneInverseContext): void {
 		const { entity, targetRelation, targetEntity } = relationContext
-		this.executionContext.addData(
-			entity.primary,
-			async ids => {
+		this.executionContext.addData({
+			field: entity.primary,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetRelation.name]: {
 						[entity.primary]: {
@@ -137,15 +115,16 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationContext,
 				], targetRelation.name)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitOneHasOneOwning(relationContext: Model.OneHasOneOwningContext): void {
 		const { relation, targetEntity } = relationContext
-		this.executionContext.addData(
-			relation.name,
-			async ids => {
+		this.executionContext.addData({
+			field: relation.name,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetEntity.primary]: {
 						in: ids,
@@ -165,15 +144,16 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationContext,
 				], targetEntity.primary)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitManyHasOne(relationContext: Model.ManyHasOneContext): void {
 		const { relation, targetEntity } = relationContext
-		this.executionContext.addData(
-			relation.name,
-			async ids => {
+		this.executionContext.addData({
+			field: relation.name,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetEntity.primary]: {
 						in: ids,
@@ -193,7 +173,13 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationContext,
 				], targetEntity.primary)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
+	}
+
+	private getRequiredPredicate(entity: Model.Entity, field: Model.AnyField): Acl.Predicate | undefined {
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, Acl.Operation.read, field.name)
+		return fieldPredicate.isSameAsPrimary ? undefined : fieldPredicate.predicate
 	}
 }

package/src/mapper/select/handlers/MetaHandler.ts

@@ -32,25 +32,14 @@ export class MetaHandler implements SelectExecutionHandler<{}> {
 		metaPath: Path,
 		operation: Acl.Operation.read | Acl.Operation.update,
 	): void {
-		const { entity, path } = context
+		const { entity } = context
 		if (entity.primary === fieldName) {
 			return
 		}
-		const fieldPredicate = this.predicateFactory.create(entity, operation, [fieldName])
-		context.addColumn(qb => {
-			return this.whereBuilder.buildAdvanced(entity, path.back(), fieldPredicate, cb =>
-				qb.select(
-					expr =>
-						expr.selectCondition(condition => {
-							condition = cb(condition)
-							if (condition.isEmpty()) {
-								return condition.raw('true')
-							}
-							return condition
-						}),
-					metaPath.alias,
-				),
-			)
-		}, metaPath)
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, operation, fieldName)
+		context.addColumn({
+			path: metaPath,
+			valueGetter: context.addPredicate(fieldPredicate.predicate),
+		})
 	}
 }

package/src/mapper/select/optimizer/WhereOptimizer.ts

@@ -11,6 +11,11 @@ type ExtendedRelationContext =
 		isLast: boolean
 	}
 
+export interface WhereOptimizationHints {
+	relationPath?: Model.AnyRelationContext[]
+	evaluatedPredicates?: Input.OptionalWhere[]
+}
+
 export class WhereOptimizer {
 	private static eliminableRelations = new Set<Model.AnyRelationContext['type']>(['oneHasMany', 'oneHasOneInverse', 'oneHasOneOwning'])
 
@@ -20,7 +25,7 @@ export class WhereOptimizer {
 	) {
 	}
 
-	public optimize(where: Input.OptionalWhere, entity: Model.Entity, relationPath: Model.AnyRelationContext[] = []): Input.Where {
+	public optimize(where: Input.OptionalWhere, entity: Model.Entity, { relationPath = [], evaluatedPredicates = [] }: WhereOptimizationHints = {}): Input.OptionalWhere {
 		let processedRelationPath: ExtendedRelationContext[] = []
 		for (const i in relationPath) {
 			const el = relationPath[i]
@@ -29,31 +34,38 @@ export class WhereOptimizer {
 			} else {
 				processedRelationPath.push({ ...el, canEliminate: true, isLast: Number(i) === relationPath.length })
 			}
-			processedRelationPath.push({ ...el, canEliminate: true, isLast: Number(i) === relationPath.length })
 		}
-		const result = this.optimizeWhere(where, entity, processedRelationPath)
+		let result = this.optimizeWhere(where, entity, processedRelationPath)
 
 		if (typeof result === 'boolean') {
 			return { [entity.primary]: { [result ? 'always' : 'never']: true } }
 		}
+		const resultTracker = { count: 0 }
+		for (const evaluated of evaluatedPredicates) {
+			const evaluatedPredicate = this.optimize(evaluated, entity)
+			result = replaceWhere(result, evaluatedPredicate, { [entity.primary]: { always: true } }, resultTracker)
+		}
+		if (resultTracker.count > 0) {
+			return this.optimize(result, entity)
+		}
 
 		return result
 	}
 
-	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
+	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
 		return this.optimizeAnd(
 			Object.entries(where).map(([key, value]) => {
 				if (value === undefined || value === null) {
 					return undefined
 
 				} else if (key === 'and') {
-					return this.optimizeAnd((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
+					return this.optimizeAnd((value as readonly Input.OptionalWhere[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
 
 				} else if (key === 'or') {
-					return this.optimizeOr((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
+					return this.optimizeOr((value as readonly Input.OptionalWhere[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
 
 				} else if (key === 'not') {
-					return optimizeNot(this.optimizeWhere(value as Input.Where, entity, relationPath))
+					return optimizeNot(this.optimizeWhere(value as Input.OptionalWhere, entity, relationPath))
 
 				} else {
 					return this.resolveFieldValue(entity, key, value, relationPath)
@@ -64,7 +76,7 @@ export class WhereOptimizer {
 		)
 	}
 
-	private optimizeOr(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
+	private optimizeOr(operands: readonly (Input.OptionalWhere | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
 		const optimized = optimizeOr(operands)
 		if (typeof optimized === 'boolean' || !Array.isArray(optimized.or)) {
 			return optimized
@@ -73,7 +85,7 @@ export class WhereOptimizer {
 		return optimizeOr(result)
 	}
 
-	private optimizeAnd(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
+	private optimizeAnd(operands: readonly (Input.OptionalWhere | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
 		const optimized = optimizeAnd(operands)
 		if (typeof optimized === 'boolean' || !Array.isArray(optimized.and)) {
 			return optimized
@@ -82,8 +94,8 @@ export class WhereOptimizer {
 		return optimizeAnd(result)
 	}
 
-	private crossOptimize(operands: Input.Where[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.Where | boolean)[] {
-		const result: (Input.Where | boolean)[] = [...operands]
+	private crossOptimize(operands: Input.OptionalWhere[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.OptionalWhere | boolean)[] {
+		const result: (Input.OptionalWhere | boolean)[] = [...operands]
 		const count = result.length
 		for (let i = 0; i < count; i++) {
 			for (let j = 0; j < count; j++) {
@@ -100,7 +112,7 @@ export class WhereOptimizer {
 	}
 
 	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string], relationPath: ExtendedRelationContext[]) {
-		return acceptFieldVisitor<Input.Where | boolean>(this.model, entity, key, {
+		return acceptFieldVisitor<Input.OptionalWhere | boolean>(this.model, entity, key, {
 			visitColumn: () => {
 				const optimizedCondition = this.conditionOptimizer.optimize(value as Input.Condition)
 
@@ -112,7 +124,7 @@ export class WhereOptimizer {
 			},
 			visitRelation: context => {
 				const { targetEntity, relation } = context
-				let where = value as Input.Where
+				let where = value as Input.OptionalWhere
 				const newRelationPath: ExtendedRelationContext[] = [...relationPath]
 				if (relationPath.length && relationPath[relationPath.length - 1].targetRelation?.name === relation.name) {
 					const item = newRelationPath.pop()

package/src/mapper/select/optimizer/WhereReplacer.ts

@@ -5,18 +5,18 @@ export interface ReplaceWhereResult {
 	count: number
 }
 
-export const replaceWhere = (subject: Input.Where, find: Input.Where, replace: Input.Where, resultTracker: ReplaceWhereResult = { count: 0 }): Input.Where => {
+export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere, resultTracker: ReplaceWhereResult = { count: 0 }): Input.OptionalWhere => {
 	if (deepEqual(subject, find)) {
 		resultTracker.count++
 		return replace
 	}
-	const result: Writable<Input.Where> = {}
+	const result: Writable<Input.OptionalWhere> = {}
 	for (const [key, value] of Object.entries(subject)) {
 		if (key === 'not') {
-			result['not'] = replaceWhere(value as Input.Where, find, replace, resultTracker)
+			result['not'] = replaceWhere(value as Input.OptionalWhere, find, replace, resultTracker)
 
 		} else if (key === 'and' || key === 'or') {
-			result[key] = (value as Input.Where[]).map(it => replaceWhere(it, find, replace, resultTracker))
+			result[key] = (value as Input.OptionalWhere[]).map(it => replaceWhere(it, find, replace, resultTracker))
 
 		} else {
 			result[key] = value

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

@@ -41,16 +41,18 @@ test('different predicate on row and field level', async () => {
 		executes: [
 			{
 				sql: SQL`
-					select "root_"."id" as "root_id",
-						case when "root_"."username" = ? then "root_"."username" else null end as "root_username"
-					from "public"."author" as "root_"
-					where not("root_"."username" is null)
+					select
+					    "root_"."id" as "root_id",
+					    "root_"."username" = ? as "root___predicate_authorPredicate",
+					    "root_"."username" as "root_username"
+					from "public"."author" as "root_" where not("root_"."username" is null)
 				`,
 				parameters: ['johndoe'],
 				response: {
 					rows: [
 						{
 							root_id: testUuid(1),
+							root___predicate_authorPredicate: true,
 							root_username: 'johndoe',
 						},
 					],
@@ -71,3 +73,51 @@ test('different predicate on row and field level', async () => {
 })
 
 
+
+test('different predicate on row and field level - false', async () => {
+	await execute({
+		schema: schema,
+		permissions: permissions,
+		variables: {},
+		query: GQL`
+        query {
+          listAuthor {
+            id
+            username
+          }
+        }`,
+		executes: [
+			{
+				sql: SQL`
+					select
+					    "root_"."id" as "root_id",
+					    "root_"."username" = ? as "root___predicate_authorPredicate",
+					    "root_"."username" as "root_username"
+					from "public"."author" as "root_" where not("root_"."username" is null)
+				`,
+				parameters: ['johndoe'],
+				response: {
+					rows: [
+						{
+							root_id: testUuid(1),
+							root___predicate_authorPredicate: false,
+							root_username: 'johndoe',
+						},
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listAuthor: [
+					{
+						id: testUuid(1),
+						username: null,
+					},
+				],
+			},
+		},
+	})
+})
+
+

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',
+					},
+				],
+			},
+		},
+	})
+})
+
+