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

package/src/mapper/select/RelationFetcher.ts

@@ -15,37 +15,26 @@ export type GroupedCounts = Record<Input.PrimaryValue, number>
 type CountOneHasManyGroupsArgs = {
 	mapper: Mapper
 	filter: Input.OptionalWhere | undefined
-	targetEntity: Model.Entity
-	targetRelation: Model.ManyHasOneRelation
+	relationPath: Model.AnyRelationContext[]
+	relationContext: Model.OneHasManyContext
 	ids: Input.PrimaryValue[]
 }
 
 type FetchOneHasManyGroupsArgs = {
 	mapper: Mapper
 	objectNode: ObjectNode<Input.ListQueryInput>
-	targetEntity: Model.Entity
-	relation: Model.OneHasManyRelation
-	targetRelation: Model.ManyHasOneRelation
+	relationPath: Model.AnyRelationContext[]
+	relationContext: Model.OneHasManyContext
 	ids: Input.PrimaryValue[]
 }
 
 type ManyHasManyBaseArgs =
 	& {
 		mapper: Mapper
-		targetEntity: Model.Entity
 		ids: Input.PrimaryValue[]
-	} & (
-		| {
-			directionFrom: 'owning'
-			sourceRelation: Model.ManyHasManyOwningRelation
-			targetRelation: Model.ManyHasManyInverseRelation | null
-		}
-		| {
-			directionFrom: 'inverse'
-			sourceRelation: Model.ManyHasManyInverseRelation
-			targetRelation: Model.ManyHasManyOwningRelation
-		}
-	)
+		relationPath: Model.AnyRelationContext[]
+		relationContext: Model.ManyHasManyInverseContext | Model.ManyHasManyOwningContext
+	}
 type CountManyHasManyGroupArgs =
 	& ManyHasManyBaseArgs
 	& {
@@ -69,22 +58,26 @@ export class RelationFetcher {
 	public async countOneHasManyGroups({
 		mapper,
 		filter,
-		targetEntity,
-		targetRelation,
+		relationContext,
+		relationPath,
 		ids,
 	}: CountOneHasManyGroupsArgs): Promise<GroupedCounts> {
+		const { targetRelation, targetEntity } = relationContext
 		const filterWithParent = this.createOneHasManyFilter(targetEntity, targetRelation, ids, filter)
-		return mapper.countGrouped(targetEntity, filterWithParent, targetRelation)
+		return mapper.countGrouped(targetEntity, filterWithParent, targetRelation, [
+			...relationPath,
+			relationContext,
+		])
 	}
 
 	public async fetchOneHasManyGroups({
 		mapper,
 		objectNode,
-		targetEntity,
-		relation,
-		targetRelation,
+		relationContext,
+		relationPath,
 		ids,
 	}: FetchOneHasManyGroupsArgs): Promise<SelectGroupedObjects> {
+		const { relation, targetEntity, targetRelation } = relationContext
 		const filter = this.createOneHasManyFilter(targetEntity, targetRelation, ids, objectNode.args.filter)
 		const objectNodeWithWhere = objectNode.withArg<Input.ListQueryInput>('filter', filter)
 		const objectNodeWithOrder = OrderByHelper.appendDefaultOrderBy(
@@ -93,7 +86,10 @@ export class RelationFetcher {
 			relation.orderBy || [],
 		)
 
-		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation)
+		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation, [
+			...relationPath,
+			relationContext,
+		])
 	}
 
 	private createOneHasManyFilter(
@@ -114,40 +110,40 @@ export class RelationFetcher {
 	public async countManyHasManyGroups({
 		mapper,
 		filter,
-		targetEntity,
-		directionFrom,
-		sourceRelation,
-		targetRelation,
+		relationContext,
+		relationPath,
 		ids,
 	}: CountManyHasManyGroupArgs): Promise<GroupedCounts> {
-		const owningRelation = directionFrom === 'owning' ? sourceRelation : targetRelation
-		const joiningColumns = this.resolveJoiningColumns({ directionFrom, owningRelation })
-		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, targetEntity, { filter })
+		const owningRelation = relationContext.type === 'manyHasManyInverse' ? relationContext.targetRelation : relationContext.relation
+
+		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
+
+		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, relationContext.targetEntity, { filter }, relationPath)
 			.select(['junction_', joiningColumns.sourceColumn.columnName])
 			.select(expr => expr.raw('count(*)'), 'row_count')
 			.groupBy(['junction_', joiningColumns.sourceColumn.columnName])
+
 		const result = new Map<string, number>()
 		const rows = await qb.getResult(mapper.db)
 		for (const row of rows) {
 			result.set(String(row[joiningColumns.sourceColumn.columnName]), Number(row.row_count))
 		}
+
 		return Object.fromEntries(result)
 	}
 
 	public async fetchManyHasManyGroups({
 		mapper,
 		field,
-		sourceRelation,
-		targetEntity,
-		targetRelation,
-		directionFrom,
+		relationContext,
+		relationPath,
 		ids,
 	}: FetchManyHasManyGroupsArgs): Promise<SelectGroupedObjects> {
-		const owningRelation = directionFrom === 'owning' ? sourceRelation : targetRelation
-		const joiningColumns = this.resolveJoiningColumns({ directionFrom, owningRelation })
-		const defaultOrderBy = sourceRelation.orderBy || []
-		const objectNode = OrderByHelper.appendDefaultOrderBy(targetEntity, field, defaultOrderBy)
-
+		const owningRelation = relationContext.type === 'manyHasManyInverse' ? relationContext.targetRelation : relationContext.relation
+		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
+		const defaultOrderBy = relationContext.relation.orderBy || []
+		const objectNode = OrderByHelper.appendDefaultOrderBy(relationContext.targetEntity, field, defaultOrderBy)
+		const { targetEntity } = relationContext
 		const junctionValues = await this.fetchJunction(
 			mapper.db,
 			owningRelation,
@@ -155,6 +151,7 @@ export class RelationFetcher {
 			joiningColumns,
 			targetEntity,
 			objectNode,
+			relationPath,
 		)
 		if (junctionValues.length === 0) {
 			return {}
@@ -173,18 +170,18 @@ export class RelationFetcher {
 				},
 			})
 			.withField(primaryField)
-		const result = await mapper.select(targetEntity, queryWithWhere, targetRelation)
+		const result = await mapper.select(targetEntity, queryWithWhere, [...relationPath, relationContext])
 
 		return this.buildManyHasManyGroups(targetEntity, joiningColumns, result, junctionValues)
 	}
 
-	private resolveJoiningColumns({ directionFrom, owningRelation }: { owningRelation: Model.ManyHasManyOwningRelation; directionFrom: 'owning' | 'inverse' }): JoiningColumns {
-		return directionFrom === 'owning' ? {
-			sourceColumn: owningRelation.joiningTable.joiningColumn,
-			targetColumn: owningRelation.joiningTable.inverseJoiningColumn,
+	private resolveJoiningColumns({ relationType, joiningTable }: { joiningTable: Model.JoiningTable; relationType: 'manyHasManyOwning' | 'manyHasManyInverse' }): JoiningColumns {
+		return relationType === 'manyHasManyOwning' ? {
+			sourceColumn: joiningTable.joiningColumn,
+			targetColumn: joiningTable.inverseJoiningColumn,
 		} : {
-			sourceColumn: owningRelation.joiningTable.inverseJoiningColumn,
-			targetColumn: owningRelation.joiningTable.joiningColumn,
+			sourceColumn: joiningTable.inverseJoiningColumn,
+			targetColumn: joiningTable.joiningColumn,
 		}
 	}
 
@@ -220,9 +217,10 @@ export class RelationFetcher {
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
 		object: ObjectNode<Input.ListQueryInput>,
+		relationPath: Model.AnyRelationContext[],
 	): Promise<Record<string, Value.AtomicValue>[]> {
 		const joiningTable = relation.joiningTable
-		const qb = this.buildJunctionQb(relation, values, column, targetEntity, object.args)
+		const qb = this.buildJunctionQb(relation, values, column, targetEntity, object.args, relationPath)
 			.select(['junction_', joiningTable.inverseJoiningColumn.columnName])
 			.select(['junction_', joiningTable.joiningColumn.columnName])
 		const wrapper = new LimitByGroupWrapper(
@@ -252,6 +250,7 @@ export class RelationFetcher {
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
 		objectArgs: Input.ListQueryInput,
+		relationPath: Model.AnyRelationContext[],
 	): SelectBuilder {
 		const joiningTable = relation.joiningTable
 
@@ -279,7 +278,7 @@ export class RelationFetcher {
 		}
 
 		if (where && hasWhere) {
-			qb = this.whereBuilder.build(qb, targetEntity, this.pathFactory.create([]), where)
+			qb = this.whereBuilder.build(qb, targetEntity, this.pathFactory.create([]), where, { relationPath })
 		}
 		return qb
 	}

package/src/mapper/select/SelectBuilder.ts

@@ -1,6 +1,6 @@
-import { Input, Model } from '@contember/schema'
+import { Acl, Input, Model } from '@contember/schema'
 import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
-import { SelectHydrator, SelectRow } from './SelectHydrator'
+import { ColumnValueGetter, SelectHydrator, SelectRow } from './SelectHydrator'
 import { Path, PathFactory } from './Path'
 import { WhereBuilder } from './WhereBuilder'
 import { Client, LimitByGroupWrapper, SelectBuilder as DbSelectBuilder } from '@contember/database'
@@ -11,6 +11,7 @@ import { MetaHandler } from './handlers'
 import { Mapper } from '../Mapper'
 import { FieldNode, ObjectNode } from '../../inputProcessing'
 import { assertNever } from '../../utils'
+import { PredicateFactory } from '../../acl'
 
 export class SelectBuilder {
 	private resolver: (value: SelectRow[]) => void = () => {
@@ -30,6 +31,8 @@ export class SelectBuilder {
 		private readonly fieldsVisitorFactory: FieldsVisitorFactory,
 		private readonly selectHandlers: { [key: string]: SelectExecutionHandler<any> },
 		private readonly pathFactory: PathFactory,
+		private readonly relationPath: Model.AnyRelationContext[],
+		private readonly predicateFactory: PredicateFactory,
 	) {}
 
 	public async execute(db: Client): Promise<SelectRow[]> {
@@ -53,7 +56,7 @@ export class SelectBuilder {
 		this.selectInternal(mapper, entity, path, input)
 		const where = input.args.filter
 		if (where) {
-			this.qb = this.whereBuilder.build(this.qb, entity, path, where)
+			this.qb = this.whereBuilder.build(this.qb, entity, path, where, { relationPath: this.relationPath })
 		}
 		const orderBy = input.args.orderBy || []
 
@@ -83,6 +86,40 @@ export class SelectBuilder {
 			input = input.withField(new FieldNode(entity.primary, entity.primary, {}))
 		}
 
+		const fetchedPredicates = new Set()
+		const addPredicate = (predicate: Acl.Predicate): ColumnValueGetter<boolean> => {
+			if (typeof predicate === 'boolean') {
+				return () => predicate
+			}
+			const predicatePath = path.for('__predicate').for(predicate)
+
+			if (!fetchedPredicates.has(predicate)) {
+				const relationContext = this.relationPath[this.relationPath.length - 1]
+
+				const primaryPredicate = this.predicateFactory.create(entity, Acl.Operation.read, undefined, relationContext)
+				const fieldPredicate = this.predicateFactory.buildPredicates(entity, [predicate], relationContext)
+
+				this.qb = this.whereBuilder.buildAdvanced(
+					entity,
+					path.back(),
+					fieldPredicate,
+					apply => this.qb.select(expr =>
+						expr.selectCondition(condition => {
+							condition = apply(condition)
+							if (condition.isEmpty()) {
+								return condition.raw('true')
+							}
+							return condition
+						}),
+					predicatePath.alias,
+					),
+					{ relationPath: this.relationPath, evaluatedPredicates: [primaryPredicate] },
+				)
+				fetchedPredicates.add(predicate)
+			}
+			return row => row[predicatePath.alias] === true
+		}
+
 		for (let field of input.fields) {
 			const fieldPath = path.for(field.alias)
 			const fieldProperty = (() => {
@@ -94,19 +131,38 @@ export class SelectBuilder {
 				}
 				return assertNever(field)
 			})()
+
+
 			const executionContext: SelectExecutionHandlerContext = {
 				mapper,
-				addData: async (fieldName, cb, defaultValue = null) => {
-					const columnName = getColumnName(this.schema, entity, fieldName)
-					const ids = (await this.getColumnValues(path.for(fieldName), columnName)).filter(it => it !== null)
+				relationPath: this.relationPath,
+				addData: async ({ field, dataProvider, defaultValue, predicate }) => {
+					if (predicate === false) {
+						this.hydrator.addPromise(fieldPath, path.for(field), 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 data = (async () => (ids.length > 0 ? cb(ids) : {}))()
-					this.hydrator.addPromise(fieldPath, path.for(fieldName), data, defaultValue)
+					const data = ids.length > 0 ? dataProvider(ids) : Promise.resolve({})
+					this.hydrator.addPromise(fieldPath, path.for(field), data, defaultValue ?? null)
 				},
-				addColumn: (qbCallback, path) => {
-					this.qb = qbCallback(this.qb)
-					this.hydrator.addColumn(path || fieldPath)
+				addColumn: ({ path = fieldPath, predicate, query, valueGetter }) => {
+					if (predicate === false) {
+						this.hydrator.addColumn(path, () => null)
+						return
+					}
+					const predicateGetter = predicate !== undefined && predicate !== true ? addPredicate(predicate) : null
+					if (query) {
+						this.qb = query(this.qb)
+					}
+					this.hydrator.addColumn(
+						path,
+						valueGetter ?? (row => predicateGetter === null || predicateGetter(row) ? row[path.alias] : null),
+					)
 				},
+				addPredicate: addPredicate,
 				path: fieldPath,
 				entity: entity,
 				...fieldProperty,
@@ -136,10 +192,12 @@ export class SelectBuilder {
 		}
 	}
 
-	private async getColumnValues(columnPath: Path, columnName: string): Promise<Input.PrimaryValue[]> {
+	private async getColumnValues(columnPath: Path, columnName: string, predicateGetter: null | ColumnValueGetter<boolean>): Promise<Input.PrimaryValue[]> {
 		this.qb = this.qb.select([columnPath.back().alias, columnName], columnPath.alias)
 		const rows = await this.rows
+		const filteredRows = predicateGetter === null ? rows : rows.filter(predicateGetter)
 		const columnAlias = columnPath.alias
-		return Array.from(new Set(rows.map((it): Input.PrimaryValue => it[columnAlias] as Input.PrimaryValue)))
+		const ids = filteredRows.map((it): Input.PrimaryValue => it[columnAlias] as Input.PrimaryValue).filter(it => it !== null)
+		return Array.from(new Set(ids))
 	}
 }

package/src/mapper/select/SelectBuilderFactory.ts

@@ -1,7 +1,8 @@
 import { SelectBuilder } from './SelectBuilder'
 import { SelectHydrator } from './SelectHydrator'
 import { SelectBuilder as DbSelectBuilder } from '@contember/database'
+import { Model } from '@contember/schema'
 
 export interface SelectBuilderFactory {
-	create(qb: DbSelectBuilder<DbSelectBuilder.Result>, hydrator: SelectHydrator): SelectBuilder
+	create(qb: DbSelectBuilder<DbSelectBuilder.Result>, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder
 }

package/src/mapper/select/SelectExecutionHandler.ts

@@ -1,6 +1,6 @@
 import { Path } from './Path'
-import { Input, Model } from '@contember/schema'
-import { SelectNestedData, SelectNestedDefaultValue } from './SelectHydrator'
+import { Acl, Input, Model } from '@contember/schema'
+import { ColumnValueGetter, SelectNestedData, SelectNestedDefaultValue, SelectRow } from './SelectHydrator'
 import { SelectBuilder } from '@contember/database'
 import { Mapper } from '../Mapper'
 import { FieldNode, ObjectNode } from '../../inputProcessing'
@@ -21,12 +21,20 @@ export type SelectExecutionHandlerContext<
 	mapper: Mapper
 	path: Path
 	entity: Model.Entity
-
-	addColumn: (
-		queryCallback: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>,
-		path?: Path,
-	) => void
-	addData: (parentField: string, cb: DataCallback, defaultValue?: SelectNestedDefaultValue) => void
+	relationPath: Model.AnyRelationContext[]
+	addPredicate: (predicate: Acl.Predicate) => (row: SelectRow) => boolean
+	addColumn: (args: {
+		predicate?: Acl.Predicate
+		query?: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>
+		path?: Path
+		valueGetter?: ColumnValueGetter
+	}) => void
+	addData: (args: {
+		field: string
+		dataProvider: DataCallback
+		predicate?: Acl.Predicate
+		defaultValue?: SelectNestedDefaultValue
+	}) => void
 } & (
 	| {
 		fieldNode: FieldNode<FieldExtensions>

package/src/mapper/select/SelectHydrator.ts

@@ -1,6 +1,7 @@
 import { Path } from './Path'
 import { Value } from '@contember/schema'
 import { getFulfilledValues, getRejections } from '../../utils'
+import { logger } from '@contember/logger'
 
 type DataPromises = {
 	path: Path
@@ -16,12 +17,19 @@ type ResolvedData = {
 	defaultValue: SelectNestedDefaultValue
 }
 
+export type ColumnValueGetter<T extends Value.FieldValue = Value.FieldValue> = (row: SelectRow) => T
+
+type Column = {
+	path: Path
+	getValue: ColumnValueGetter
+}
+
 export class SelectHydrator {
-	private columns: Path[] = []
+	private columns: Column[] = []
 	private promises: DataPromises[] = []
 
-	public addColumn(path: Path) {
-		this.columns.push(path)
+	public addColumn(path: Path, getValue: ColumnValueGetter) {
+		this.columns.push({ path, getValue })
 	}
 
 	public addPromise(
@@ -72,12 +80,11 @@ export class SelectHydrator {
 		const result: SelectResultObject = {}
 
 		for (let columnPath of this.columns) {
-			const path = [...columnPath.path]
+			const path = [...columnPath.path.path]
 			const last: string = path.pop() as string
 			const currentObject = path.reduce<any>((obj, part) => (obj[part] = obj[part] || {}), result)
 
-			const field = row[columnPath.alias]
-			currentObject[last] = this.formatValue(field)
+			currentObject[last] = this.formatValue(columnPath.getValue(row))
 		}
 
 		for (let { path, parentKeyPath, data, defaultValue } of resolvedData) {
@@ -103,10 +110,7 @@ export class SelectHydrator {
 		const failures = getRejections(results)
 		if (failures.length > 0) {
 			if (failures.length > 1) {
-				// eslint-disable-next-line no-console
-				console.error('Multiple error has occurred, printing them & rethrowing the first one')
-				// eslint-disable-next-line no-console
-				failures.slice(1).map(e => console.error(e))
+				failures.slice(1).map(e => logger.error(e, { loc: 'SelectHydrator' }))
 			}
 			throw failures[0]
 		}
@@ -122,7 +126,7 @@ export class SelectHydrator {
 	}
 }
 
-export type SelectRow = { [key: string]: Value.AtomicValue }
+export type SelectRow = { [key: string]: Value.FieldValue }
 export type SelectResultObject = Value.Object
 export type SelectIndexedResultObjects = { [key: string]: SelectResultObject }
 export type SelectGroupedObjects = { [groupingKey: string]: SelectResultObject[] }