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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-alpha.11",
+  "version": "1.2.0-alpha.13",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,19 +10,19 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.0-alpha.11",
-    "@contember/dic": "^1.2.0-alpha.11",
-    "@contember/engine-common": "^1.2.0-alpha.11",
-    "@contember/graphql-utils": "^1.2.0-alpha.11",
-    "@contember/schema": "^1.2.0-alpha.11",
-    "@contember/schema-utils": "^1.2.0-alpha.11",
+    "@contember/database": "^1.2.0-alpha.13",
+    "@contember/dic": "^1.2.0-alpha.13",
+    "@contember/engine-common": "^1.2.0-alpha.13",
+    "@contember/graphql-utils": "^1.2.0-alpha.13",
+    "@contember/schema": "^1.2.0-alpha.13",
+    "@contember/schema-utils": "^1.2.0-alpha.13",
     "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-alpha.11",
-    "@contember/engine-api-tester": "^1.2.0-alpha.11",
-    "@contember/schema-definition": "^1.2.0-alpha.11",
+    "@contember/database-tester": "^1.2.0-alpha.13",
+    "@contember/engine-api-tester": "^1.2.0-alpha.13",
+    "@contember/schema-definition": "^1.2.0-alpha.13",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/acl/EvaluatedPredicateReplacer.ts

@@ -3,17 +3,17 @@ import { replaceWhere } from '../mapper/select/optimizer/WhereReplacer'
 
 export class EvaluatedPredicateReplacer {
 	constructor(
-		private readonly evaluatedPredicate: Input.Where,
+		private readonly evaluatedPredicate: Input.OptionalWhere,
 		private readonly sourceEntity: Model.Entity,
 		private readonly relation: Model.AnyRelation,
 	) {
 	}
 
-	public replace(where: Input.Where): Input.Where {
-		const result: Writable<Input.Where> = {}
+	public replace(where: Input.OptionalWhere): Input.OptionalWhere {
+		const result: Writable<Input.OptionalWhere> = {}
 		for (const [key, value] of Object.entries(where)) {
 			if (key === 'not') {
-				result['not'] = this.replace(value as Input.Where)
+				result['not'] = this.replace(value as Input.OptionalWhere)
 
 			} else if (key === 'and' || key === 'or') {
 				result[key] = (value as Input.Where[]).map(it => this.replace(it))

package/src/acl/PredicateFactory.ts

@@ -4,6 +4,11 @@ import { EvaluatedPredicateReplacer } from './EvaluatedPredicateReplacer'
 
 const getRowLevelPredicatePseudoField = (entity: Model.Entity) => entity.primary
 
+export interface FieldRequiredPredicate {
+	predicate: Acl.Predicate
+	isSameAsPrimary: boolean
+}
+
 export class PredicateFactory {
 	constructor(
 		private readonly permissions: Acl.Permissions,
@@ -11,6 +16,24 @@ export class PredicateFactory {
 		private readonly variableInjector: VariableInjector,
 	) {}
 
+	public getFieldPredicate(
+		entity: Model.Entity,
+		operation: Acl.Operation.update | Acl.Operation.read | Acl.Operation.create,
+		fieldName: string,
+	): FieldRequiredPredicate {
+		const permissions = this.permissions[entity.name]?.operations?.[operation]
+		const predicate = permissions?.[fieldName] ?? false
+		const rowLevelField = getRowLevelPredicatePseudoField(entity)
+
+		const primaryPredicate = permissions?.[rowLevelField] ?? false
+		const isSameAsPrimary = predicate === primaryPredicate
+
+		return {
+			isSameAsPrimary,
+			predicate,
+		}
+	}
+
 	public shouldApplyCellLevelPredicate(
 		entity: Model.Entity,
 		operation: Acl.Operation.read,
@@ -21,22 +44,28 @@ export class PredicateFactory {
 		return permissions?.[fieldName] !== permissions?.[rowLevelField]
 	}
 
-	public create(
-		entity: Model.Entity,
-		operation: Acl.Operation.delete,
-	): Input.Where
+	public createDeletePredicate(entity: Model.Entity) {
+		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
+		const entityPermissions = this.permissions[entity.name]
+		if (!entityPermissions) {
+			return neverCondition
+		}
+		const deletePredicate = entityPermissions.operations.delete
+		if (deletePredicate === undefined || deletePredicate === false) {
+			return neverCondition
+		}
+		if (deletePredicate === true) {
+			return {}
+		}
+		return this.buildPredicates(entity, [deletePredicate])
+	}
+
 	public create(
 		entity: Model.Entity,
 		operation: Acl.Operation.update | Acl.Operation.read | Acl.Operation.create,
-		fieldNames?: string[],
-		relationContext?: Model.AnyRelationContext,
-	): Input.Where
-	public create(
-		entity: Model.Entity,
-		operation: Acl.Operation,
-		fieldNames?: string[],
+		fieldNames: string[] = [getRowLevelPredicatePseudoField(entity)],
 		relationContext?: Model.AnyRelationContext,
-	): Input.Where {
+	): Input.OptionalWhere {
 		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name]
 		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
 
@@ -44,31 +73,24 @@ export class PredicateFactory {
 			return neverCondition
 		}
 
-		let predicates: Acl.PredicateReference[]
-		if (operation === Acl.Operation.delete) {
-			const deletePredicate = entityPermissions.operations.delete
-			if (deletePredicate === undefined || deletePredicate === false) {
-				return neverCondition
-			}
-			if (deletePredicate === true) {
-				return {}
-			}
-			predicates = [deletePredicate]
-		} else {
-			if (fieldNames === undefined) {
-				fieldNames = [getRowLevelPredicatePseudoField(entity)]
-			}
-			const fieldPermissions = entityPermissions.operations[operation]
-			if (fieldPermissions === undefined) {
-				return neverCondition
-			}
-			const operationPredicates = this.getRequiredPredicates(fieldNames, fieldPermissions)
-			if (operationPredicates === false) {
-				return neverCondition
-			}
-			predicates = operationPredicates
+		if (fieldNames === undefined) {
+			fieldNames = [getRowLevelPredicatePseudoField(entity)]
+		}
+		const fieldPermissions = entityPermissions.operations[operation]
+		if (fieldPermissions === undefined) {
+			return neverCondition
+		}
+		const operationPredicates = this.getRequiredPredicates(fieldNames, fieldPermissions)
+		if (operationPredicates === false) {
+			return neverCondition
 		}
 
+		return this.buildPredicates(entity, operationPredicates, relationContext)
+	}
+
+	public buildPredicates(entity: Model.Entity, predicates: Acl.PredicateReference[], relationContext?: Model.AnyRelationContext): Input.OptionalWhere {
+		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name] ?? {}
+
 		const predicatesWhere: Input.Where[] = predicates.reduce(
 			(result: Input.Where[], name: Acl.PredicateReference): Input.Where[] => {
 				if (!entityPermissions.predicates[name]) {
@@ -84,6 +106,7 @@ export class PredicateFactory {
 		}
 		const where: Input.Where = predicatesWhere.length === 1 ? predicatesWhere[0] : { and: predicatesWhere }
 		return this.optimizePredicates(where, relationContext)
+
 	}
 
 	private getRequiredPredicates(
@@ -106,7 +129,7 @@ export class PredicateFactory {
 		return predicates
 	}
 
-	private optimizePredicates(where: Input.Where, relationContext?: Model.AnyRelationContext) {
+	public optimizePredicates(where: Input.OptionalWhere, relationContext?: Model.AnyRelationContext) {
 		if (!relationContext || !relationContext.targetRelation) {
 			return where
 		}

package/src/acl/PredicatesInjector.ts

@@ -16,7 +16,8 @@ export class PredicatesInjector {
 		where: Input.OptionalWhere,
 		relationContext?: Model.AnyRelationContext,
 	): Input.OptionalWhere {
-		const predicatesWhere: Input.Where = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext)
+		const predicatesWhere = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext)
+		where = this.predicateFactory.optimizePredicates(where, relationContext)
 
 		const and = [where, predicatesWhere].filter(it => Object.keys(it).length > 0)
 		if (and.length === 0) {

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducerExecutionHandler.ts

@@ -15,9 +15,9 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 		if (!objectNode) {
 			throw new Error()
 		}
-		addData(
-			entity.primary,
-			async (ids: Input.PrimaryValue[]) => {
+		addData({
+			field: entity.primary,
+			dataProvider: async (ids: Input.PrimaryValue[]) => {
 
 				const relationContext = acceptFieldVisitor(this.schema, entity, objectNode.extensions.relationName, {
 					visitRelation: context => context,
@@ -48,7 +48,7 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 					relationContext,
 				], targetRelation.name)
 			},
-			null,
-		)
+			defaultValue: null,
+		})
 	}
 }

package/src/extensions/paginatedHasMany/PaginatedHasManyExecutionHandler.ts

@@ -20,9 +20,9 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 			throw new Error()
 		}
 		const pagination = createPaginationHelper(objectNode)
-		addData(
-			context.entity.primary,
-			async ids => {
+		addData({
+			field: context.entity.primary,
+			dataProvider: async ids => {
 				const counts = pagination.requiresTotalCount
 					? await acceptFieldVisitor(
 						this.schema,
@@ -46,7 +46,7 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 				}
 				return Object.fromEntries(result)
 			},
-			pagination.createResponse(0, []),
-		)
+			defaultValue: pagination.createResponse(0, []),
+		})
 	}
 }

package/src/mapper/JunctionTableManager.ts

@@ -87,7 +87,7 @@ export class JunctionTableManager {
 		}
 
 		const owningPredicate = this.predicateFactory.create(owningEntity, Acl.Operation.update, [relation.name])
-		let inversePredicate: Input.Where = {}
+		let inversePredicate: Input.OptionalWhere = {}
 		if (relation.inversedBy) {
 			inversePredicate = this.predicateFactory.create(inverseEntity, Acl.Operation.update, [relation.inversedBy])
 		}
@@ -99,11 +99,11 @@ export class JunctionTableManager {
 		if (hasNoPredicates) {
 			return await handler.executeSimple({ db, joiningTable, owningPrimary, inversePrimary, okResultFactory })
 		} else {
-			const owningWhere: Input.Where = {
+			const owningWhere: Input.OptionalWhere = {
 				and: [owningPredicate, { [owningEntity.primary]: { eq: owningPrimary } }],
 			}
 
-			const inverseWhere: Input.Where = {
+			const inverseWhere: Input.OptionalWhere = {
 				and: [inversePredicate, { [inverseEntity.primary]: { eq: inversePrimary } }],
 			}
 

package/src/mapper/Mapper.ts

@@ -50,7 +50,7 @@ export class Mapper {
 			.from(entity.tableName, 'root_')
 			.select(['root_', columnName])
 		const expandedWhere = this.uniqueWhereExpander.expand(entity, where)
-		const builtQb = this.whereBuilder.build(qb, entity, this.pathFactory.create([]), expandedWhere, [])
+		const builtQb = this.whereBuilder.build(qb, entity, this.pathFactory.create([]), expandedWhere)
 		const result = await builtQb.getResult(this.db)
 
 		return result[0] !== undefined ? result[0][columnName] : undefined
@@ -136,7 +136,7 @@ export class Mapper {
 			.from(entity.tableName, path.alias)
 			.select(expr => expr.raw('count(*)'), 'row_count')
 		const withPredicates = this.predicatesInjector.inject(entity, filter)
-		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates, [])
+		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates)
 		const result = await qbWithWhere.getResult(this.db)
 		return result[0].row_count
 	}
@@ -154,7 +154,7 @@ export class Mapper {
 			.select([path.alias, relation.joiningColumn.columnName])
 			.groupBy([path.alias, relation.joiningColumn.columnName])
 		const withPredicates = this.predicatesInjector.inject(entity, filter)
-		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates, relationPath)
+		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates, { relationPath })
 		const rows = await qbWithWhere.getResult(this.db)
 		const result = new Map<string, number>()
 		for (const row of rows) {

package/src/mapper/MapperContainer.ts

@@ -84,7 +84,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 			[HasManyToHasOneReducer.extensionName]: hasManyToHasOneReducer,
 			[PaginatedHasManyFieldProvider.extensionName]: paginatedHasManyExecutionHandler,
 		}))
-		.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory }) =>
+		.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory, predicateFactory }) =>
 			new (class implements SelectBuilderFactory {
 				create(qb: DbSelectBuilder, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder {
 					return new SelectBuilder(
@@ -98,6 +98,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 						selectHandlers,
 						pathFactory,
 						relationPath,
+						predicateFactory,
 					)
 				}
 			})())

package/src/mapper/delete/DeleteExecutor.ts

@@ -57,7 +57,7 @@ export class DeleteExecutor {
 
 	private async delete(mapper: Mapper, entity: Model.Entity, where: Input.OptionalWhere): Promise<string[]> {
 		const db = mapper.db
-		const predicate = this.predicateFactory.create(entity, Acl.Operation.delete)
+		const predicate = this.predicateFactory.createDeletePredicate(entity)
 		const inQb = SelectBuilder.create() //
 			.from(entity.tableName, 'root_')
 			.select(['root_', entity.primaryColumn])

package/src/mapper/insert/InsertBuilder.ts

@@ -20,7 +20,7 @@ export class InsertBuilder {
 	public readonly insert: Promise<Value.PrimaryValue | null> = new Promise(resolve => (this.resolver = resolve))
 
 	private rowData: ColumnValue<AbortInsert | undefined>[] = []
-	private where: Input.Where = {}
+	private where: Input.OptionalWhere = {}
 
 	constructor(
 		private readonly schema: Model.Schema,
@@ -35,7 +35,7 @@ export class InsertBuilder {
 		this.rowData.push({ columnName, value: resolveGenericValue(value), columnType, fieldName })
 	}
 
-	public addWhere(where: Input.Where): void {
+	public addWhere(where: Input.OptionalWhere): void {
 		this.where = { and: [where, this.where] }
 	}
 

package/src/mapper/select/RelationFetcher.ts

@@ -278,7 +278,7 @@ export class RelationFetcher {
 		}
 
 		if (where && hasWhere) {
-			qb = this.whereBuilder.build(qb, targetEntity, this.pathFactory.create([]), where, relationPath)
+			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 = () => {
@@ -31,6 +32,7 @@ export class SelectBuilder {
 		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[]> {
@@ -54,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.relationPath)
+			this.qb = this.whereBuilder.build(this.qb, entity, path, where, { relationPath: this.relationPath })
 		}
 		const orderBy = input.args.orderBy || []
 
@@ -84,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 = (() => {
@@ -95,20 +131,38 @@ export class SelectBuilder {
 				}
 				return assertNever(field)
 			})()
+
+
 			const executionContext: SelectExecutionHandlerContext = {
 				mapper,
 				relationPath: this.relationPath,
-				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)
+				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,
@@ -138,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/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'
@@ -22,12 +22,19 @@ export type SelectExecutionHandlerContext<
 	path: Path
 	entity: Model.Entity
 	relationPath: Model.AnyRelationContext[]
-
-	addColumn: (
-		queryCallback: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>,
-		path?: Path,
-	) => void
-	addData: (parentField: string, cb: DataCallback, defaultValue?: SelectNestedDefaultValue) => void
+	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

@@ -16,12 +16,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 +79,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) {
@@ -122,7 +128,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[] }