@contember/engine-content-api 1.1.0-alpha.5 → 1.1.0-alpha.8

package/package.json

@@ -1,36 +1,35 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.1.0-alpha.5",
+  "version": "1.1.0-alpha.8",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
   "scripts": {
     "build-copy": "mkdir -p dist && find ./tests/ -name '*.gql' -type f -exec cp --parents {} ./dist \\;",
     "generate": "gql-gen --config graphql.codegen.yml",
-    "test": "uvu dist/tests/cases/ \\.js$"
+    "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.1.0-alpha.5",
-    "@contember/dic": "^1.1.0-alpha.5",
-    "@contember/engine-common": "^1.1.0-alpha.5",
-    "@contember/graphql-utils": "^1.1.0-alpha.5",
-    "@contember/schema": "^1.1.0-alpha.5",
-    "@contember/schema-utils": "^1.1.0-alpha.5",
-    "@graphql-tools/schema": "^7.1.5",
+    "@contember/database": "^1.1.0-alpha.8",
+    "@contember/dic": "^1.1.0-alpha.8",
+    "@contember/engine-common": "^1.1.0-alpha.8",
+    "@contember/graphql-utils": "^1.1.0-alpha.8",
+    "@contember/schema": "^1.1.0-alpha.8",
+    "@contember/schema-utils": "^1.1.0-alpha.8",
+    "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.1.0-alpha.5",
-    "@contember/engine-api-tester": "^1.1.0-alpha.5",
-    "@contember/schema-definition": "^1.1.0-alpha.5",
+    "@contember/database-tester": "^1.1.0-alpha.8",
+    "@contember/engine-api-tester": "^1.1.0-alpha.8",
+    "@contember/schema-definition": "^1.1.0-alpha.8",
     "@graphql-codegen/cli": "^1.15.2",
     "@graphql-codegen/typescript": "^1.15.2",
     "@graphql-codegen/typescript-operations": "^1.15.2",
     "@graphql-codegen/typescript-resolvers": "^1.15.2",
     "@types/node": "^17.0.5",
     "graphql": "^15.4.0",
-    "pg": "^8.5.0",
-    "uvu": "^0.5.3"
+    "pg": "^8.5.0"
   },
   "peerDependencies": {
     "graphql": ">= 14.6.0",

package/src/acl/Authorizator.ts

@@ -4,7 +4,10 @@ import { Acl } from '@contember/schema'
 export type AuthorizationResult = 'yes' | 'no' | 'maybe'
 
 export class Authorizator {
-	constructor(private readonly permissions: Acl.Permissions) {
+	constructor(
+		private readonly permissions: Acl.Permissions,
+		private readonly defaultCustomPrimary: boolean,
+	) {
 	}
 
 	getEntityPermission(operation: Acl.Operation, entity: string): AuthorizationResult {
@@ -47,6 +50,6 @@ export class Authorizator {
 
 
 	isCustomPrimaryAllowed(entity: string): boolean {
-		return this.permissions?.[entity]?.operations?.customPrimary || false
+		return this.permissions?.[entity]?.operations?.customPrimary ?? this.defaultCustomPrimary
 	}
 }

package/src/acl/PermissionFactory.ts

@@ -1,4 +1,4 @@
-import { Acl, Model } from '@contember/schema'
+import { Acl, Model, Writable } from '@contember/schema'
 import { getEntity, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { mapObject } from '../utils'
 import { prefixVariable } from './VariableUtils'
@@ -6,7 +6,7 @@ import { prefixVariable } from './VariableUtils'
 export class PermissionFactory {
 	constructor(private readonly schema: Model.Schema) {}
 
-	public create(acl: Acl.Schema, roles: string[], prefix?: string): Acl.Permissions {
+	public create(acl: Acl.Schema, roles: readonly string[], prefix?: string): Acl.Permissions {
 		let result: Acl.Permissions = {}
 		for (let role of roles) {
 			const roleDefinition = acl.roles[role] || { entities: {} }
@@ -49,10 +49,11 @@ export class PermissionFactory {
 		for (let entityName in permissions) {
 			const entity = getEntity(this.schema, entityName)
 			const entityPermissions: Acl.EntityPermissions = permissions[entityName]
+			const entityPredicates: Writable<Acl.PredicateMap> = entityPermissions.predicates
 
 			const operationNames = ['read', 'create', 'update'] as const
 			for (let operation of operationNames) {
-				const fieldPermissions: Acl.FieldPermissions | undefined = entityPermissions.operations[operation]
+				const fieldPermissions: Writable<Acl.FieldPermissions> | undefined = entityPermissions.operations[operation]
 				if (fieldPermissions === undefined) {
 					continue
 				}
@@ -85,8 +86,7 @@ export class PermissionFactory {
 					predicates[predicate] = predicateDefinition
 				}
 				fieldPermissions[entity.primary] = idPermissions
-				entityPermissions.predicates[idPermissions as Acl.PredicateReference] =
-					predicates[idPermissions as Acl.PredicateReference]
+				entityPredicates[idPermissions as Acl.PredicateReference] = predicates[idPermissions as Acl.PredicateReference]
 			}
 		}
 	}
@@ -104,8 +104,8 @@ export class PermissionFactory {
 	}
 
 	private mergeEntityPermissions(left: Acl.EntityPermissions, right: Acl.EntityPermissions): Acl.EntityPermissions {
-		let predicates: Acl.PredicateMap = {}
-		const operations: Acl.EntityOperations = {}
+		let predicates: Writable<Acl.PredicateMap> = {}
+		const operations: Writable<Acl.EntityOperations> = {}
 		if (left.operations.customPrimary || right.operations.customPrimary) {
 			operations.customPrimary = true
 		}
@@ -156,8 +156,8 @@ export class PermissionFactory {
 		rightPredicates: Acl.PredicateMap,
 		rightFieldPermissions: Acl.FieldPermissions,
 	): [Acl.PredicateMap, Acl.FieldPermissions] {
-		const fields: Acl.FieldPermissions = {}
-		const predicates: Acl.PredicateMap = {}
+		const fields: Writable<Acl.FieldPermissions> = {}
+		const predicates: Writable<Acl.PredicateMap> = {}
 
 		for (let field in { ...leftFieldPermissions, ...rightFieldPermissions }) {
 			const [predicateDefinition, predicate] = this.mergePredicates(

package/src/acl/PredicatesInjector.ts

@@ -1,4 +1,4 @@
-import { Acl, Input, Model } from '@contember/schema'
+import { Acl, Input, Model, Writable } from '@contember/schema'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { PredicateFactory } from './PredicateFactory'
 
@@ -28,7 +28,7 @@ export class PredicatesInjector {
 	}
 
 	private injectToWhere(where: Input.OptionalWhere, entity: Model.Entity): Input.OptionalWhere {
-		const resultWhere: Input.OptionalWhere = {}
+		const resultWhere: Writable<Input.OptionalWhere> = {}
 		if (where.and) {
 			resultWhere.and = where.and.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity))
 		}

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor.ts

@@ -3,6 +3,7 @@ import { FieldMap } from '../EntityFieldsProvider'
 import { PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider'
 import { capitalizeFirstLetter } from '../../utils'
 import { PaginatedFieldConfigFactory } from '../../schema/PaginatedFieldConfigFactory'
+import { aliasAwareResolver } from '../../schema'
 
 export class PaginatedHasManyFieldProviderVisitor implements
 	Model.ColumnVisitor<FieldMap<PaginatedHasManyFieldProviderExtension>>,
@@ -47,6 +48,7 @@ export class PaginatedHasManyFieldProviderVisitor implements
 				extensions: {
 					relationName: relation.name,
 				},
+				resolve: aliasAwareResolver,
 			},
 		}
 	}

package/src/input-validation/ValidationEvaluation.ts

@@ -97,7 +97,7 @@ const validatorEvaluators: {
 			visitUndefinedContext: fixedResult(false),
 		})
 	},
-	pattern: (context: ValidationContext.AnyContext, patternArgument: Validation.LiteralArgument<[string, string]>) => {
+	pattern: (context: ValidationContext.AnyContext, patternArgument: Validation.LiteralArgument<readonly [string, string]>) => {
 		return acceptContextVisitor(context, {
 			visitNodeContext: cannotApplyOnNode('pattern', 'node'),
 			visitNodeListContext: cannotApplyOnNode('pattern', 'node list'),

package/src/inputProcessing/UniqueWhereExpander.ts

@@ -1,4 +1,4 @@
-import { Input, Model } from '@contember/schema'
+import { Input, Model, Writable } from '@contember/schema'
 import { getTargetEntity } from '@contember/schema-utils'
 import { UserError } from '../exception'
 import { getFieldsForUniqueWhere } from '../utils'
@@ -30,7 +30,7 @@ export class UniqueWhereExpander {
 			throw new UniqueWhereError(this.formatErrorMessage(entity, where, path))
 		}
 
-		const whereExpanded: Input.Where = {}
+		const whereExpanded: Writable<Input.Where> = {}
 		for (const field in where) {
 			if (!isFilled(field)) {
 				continue

package/src/introspection/IntrospectionSchemaFactory.ts

@@ -116,7 +116,7 @@ export class IntrospectionSchemaFactory {
 			}))
 	}
 
-	createValidationSchema(rules: Validation.ValidationRule[]): Pick<ContentSchema._Field, 'rules' | 'validators'> {
+	createValidationSchema(rules: readonly Validation.ValidationRule[]): Pick<ContentSchema._Field, 'rules' | 'validators'> {
 		const validators: ContentSchema._Validator[] = []
 
 		const processValidator = (validator: Validation.Validator) => {

package/src/mapper/Mapper.ts

@@ -72,8 +72,8 @@ export class Mapper {
 		let indexByAlias: string | null = null
 		if (indexBy) {
 			const path = this.pathFactory.create([])
-			indexByAlias = path.for(indexBy).getAlias()
-			qb = qb.select([path.getAlias(), getColumnName(this.schema, entity, indexBy)], indexByAlias)
+			indexByAlias = path.for(indexBy).alias
+			qb = qb.select([path.alias, getColumnName(this.schema, entity, indexBy)], indexByAlias)
 		}
 		const rows = await this.selectRows(hydrator, qb, entity, input)
 
@@ -100,7 +100,7 @@ export class Mapper {
 		let qb: SelectBuilder<SelectBuilder.Result> = SelectBuilder.create()
 		const path = this.pathFactory.create([])
 		const groupingKey = '__grouping_key'
-		qb = qb.select([path.getAlias(), relation.joiningColumn.columnName], groupingKey)
+		qb = qb.select([path.alias, relation.joiningColumn.columnName], groupingKey)
 
 		const rows = await this.selectRows(hydrator, qb, entity, input, relation.name)
 		return await hydrator.hydrateGroups(rows, groupingKey)
@@ -115,22 +115,19 @@ export class Mapper {
 	) {
 		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, [])
 		const path = this.pathFactory.create([])
-		const augmentedBuilder = qb.from(entity.tableName, path.getAlias()).meta('path', [...input.path, input.alias])
+		const augmentedBuilder = qb.from(entity.tableName, path.alias).meta('path', [...input.path, input.alias])
 
 		const selector = this.selectBuilderFactory.create(augmentedBuilder, hydrator)
 		const filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {})
 		const inputWithPredicates = inputWithOrder.withArg('filter', filterWithPredicates)
-		const selectPromise = selector.select(this, entity, inputWithPredicates, path, groupBy)
-		const rows = await selector.execute(this.db)
-		await selectPromise
-
-		return rows
+		selector.select(this, entity, inputWithPredicates, path, groupBy)
+		return await selector.execute(this.db)
 	}
 
 	public async count(entity: Model.Entity, filter: Input.OptionalWhere) {
 		const path = this.pathFactory.create([])
 		const qb = SelectBuilder.create()
-			.from(entity.tableName, path.getAlias())
+			.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)
@@ -145,10 +142,10 @@ export class Mapper {
 	): Promise<Record<string, number>> {
 		const path = this.pathFactory.create([])
 		const qb = SelectBuilder.create()
-			.from(entity.tableName, path.getAlias())
+			.from(entity.tableName, path.alias)
 			.select(expr => expr.raw('count(*)'), 'row_count')
-			.select([path.getAlias(), relation.joiningColumn.columnName])
-			.groupBy([path.getAlias(), relation.joiningColumn.columnName])
+			.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)
 		const rows = await qbWithWhere.getResult(this.db)

package/src/mapper/insert/SqlCreateInputProcessor.ts

@@ -18,7 +18,7 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<MutationRes
 	public async column(context: Context.ColumnContext): Promise<MutationResultList> {
 		this.insertBuilder.addFieldValue(
 			context.column.name,
-			((): Value.GenericValueLike<Value.AtomicValue> => {
+			((): Value.GenericValueLike<Value.AtomicValue | undefined> => {
 				return resolveColumnValue(context, this.providers)
 			})(),
 		)

package/src/mapper/select/JoinBuilder.ts

@@ -22,11 +22,11 @@ export class JoinBuilder {
 		const joins = acceptRelationTypeVisitor(this.schema, entity, relationName, new JoinVisitor(path))
 
 		return joins.reduce<SelectBuilder<SelectBuilder.Result>>((qb, join) => {
-			const targetAlias = join.targetAlias || path.getAlias()
+			const targetAlias = join.targetAlias || path.alias
 			if (qb.options.join.find(it => it.alias === targetAlias)) {
 				return qb
 			}
-			const sourceAlias = join.sourceAlias || path.back().getAlias()
+			const sourceAlias = join.sourceAlias || path.back().alias
 
 			return qb.leftJoin(join.tableName, targetAlias, clause =>
 				clause.compareColumns([sourceAlias, join.sourceColumn], Operator.eq, [targetAlias, join.targetColumn]),

package/src/mapper/select/JoinVisitor.ts

@@ -68,8 +68,8 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 		relation: Model.ManyHasManyOwningRelation,
 		targetEntity: Model.Entity,
 	): JoinDefinition[] {
-		const sourceAlias = this.path.back().getAlias()
-		const targetAlias = this.path.getAlias()
+		const sourceAlias = this.path.back().alias
+		const targetAlias = this.path.alias
 		const joiningAlias = `${sourceAlias}_x_${targetAlias}`
 		return [
 			{
@@ -96,8 +96,8 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyOwningRelation,
 	): JoinDefinition[] {
-		const sourceAlias = this.path.back().getAlias()
-		const targetAlias = this.path.getAlias()
+		const sourceAlias = this.path.back().alias
+		const targetAlias = this.path.alias
 		const joiningAlias = `${sourceAlias}_x_${targetAlias}`
 		return [
 			{

package/src/mapper/select/OrderByBuilder.ts

@@ -30,7 +30,7 @@ export class OrderByBuilder {
 	): [SelectBuilder<SelectBuilder.Result>, Orderable] {
 		const entries = Object.entries(orderBy)
 		if (entries.length !== 1) {
-			const fields = entries.join(', ')
+			const fields = entries.map(it => it[0]).join(', ')
 			throw new UserError('Order by: only one field is expected in each item of order by clause, got: ' + fields)
 		}
 		if (orderBy._random || orderBy._randomSeeded) {
@@ -56,7 +56,7 @@ export class OrderByBuilder {
 		if (typeof value === 'string') {
 			const columnName = getColumnName(this.schema, entity, fieldName)
 			const applyOrder = <Orderable extends QueryBuilder.Orderable<any>>(orderable: Orderable) =>
-				orderable.orderBy([path.getAlias(), columnName], value as Input.OrderDirection)
+				orderable.orderBy([path.alias, columnName], value)
 
 			qb = applyOrder(qb)
 			if (orderable !== null) {

package/src/mapper/select/OrderByHelper.ts

@@ -5,7 +5,7 @@ export class OrderByHelper {
 	public static appendDefaultOrderBy(
 		entity: Model.Entity,
 		objectNode: ObjectNode<Input.ListQueryInput>,
-		defaultOrderBy: Model.OrderBy[],
+		defaultOrderBy: readonly Model.OrderBy[],
 	): ObjectNode<Input.ListQueryInput> {
 		const inputOrder = objectNode.args.orderBy || []
 		const hasOrderBy = inputOrder.length > 0
@@ -26,16 +26,16 @@ export class OrderByHelper {
 		return objectNode.withArg('orderBy', [...(inputOrder || []), ...orderBy])
 	}
 
-	private static buildOrderBy(defaultOrderBy: Model.OrderBy[]): Input.OrderByFields[] {
+	private static buildOrderBy(defaultOrderBy: readonly Model.OrderBy[]): Input.OrderByFields[] {
 		return defaultOrderBy
 			.map(({ path, direction }): Input.OrderByFields | null => {
-				path = [...path]
-				const lastItem = path.pop()
+				const mutablePath = [...path]
+				const lastItem = mutablePath.pop()
 				if (!lastItem) {
 					return null
 				}
 				const columnOrderBy = { [lastItem]: direction }
-				return path.reverse().reduce<Input.OrderByFields>((value, field) => ({ [field]: value }), columnOrderBy)
+				return mutablePath.reverse().reduce<Input.OrderByFields>((value, field) => ({ [field]: value }), columnOrderBy)
 			})
 			.filter((it): it is Input.OrderByFields => !!it)
 	}

package/src/mapper/select/Path.ts

@@ -25,6 +25,8 @@ export class PathFactory {
 }
 
 export class Path {
+	public readonly alias = this.createAlias()
+
 	constructor(
 		public readonly path: string[],
 		private readonly aliasContext: AliasContext,
@@ -41,7 +43,7 @@ export class Path {
 		return new Path([...this.path, path], this.aliasContext, this.rootAlias)
 	}
 
-	public getAlias(): string {
+	private createAlias(): string {
 		const alias = this.rootAlias + this.path.join('_')
 
 		// intentionally not allowing == MAX_IDENTIFIER_LENGTH
@@ -49,6 +51,6 @@ export class Path {
 			return alias
 		}
 		const index = this.aliasContext.getAliasIndex(alias).toString()
-		return alias.substr(0, MAX_IDENTIFIER_LENGTH - index.length - 1) + '_' + index
+		return alias.substring(0, MAX_IDENTIFIER_LENGTH - index.length - 1) + '_' + index
 	}
 }

package/src/mapper/select/RelationFetcher.ts

@@ -209,9 +209,9 @@ export class RelationFetcher {
 
 		if (hasWhere || hasFieldOrderBy) {
 			const path = this.pathFactory.create([])
-			qb = qb.join(targetEntity.tableName, path.getAlias(), condition =>
+			qb = qb.join(targetEntity.tableName, path.alias, condition =>
 				condition.compareColumns(['junction_', column.targetColumn.columnName], Operator.eq, [
-					path.getAlias(),
+					path.alias,
 					targetEntity.primaryColumn,
 				]),
 			)

package/src/mapper/select/SelectBuilder.ts

@@ -43,14 +43,14 @@ export class SelectBuilder {
 		return result
 	}
 
-	public async select(
+	public select(
 		mapper: Mapper,
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
 		path: Path,
 		groupBy?: string,
 	) {
-		const promise = this.selectInternal(mapper, entity, path, input)
+		this.selectInternal(mapper, entity, path, input)
 		const where = input.args.filter
 		if (where) {
 			this.qb = this.whereBuilder.build(this.qb, entity, path, where)
@@ -60,7 +60,7 @@ export class SelectBuilder {
 		if (groupBy) {
 			const groupByColumn = getColumnName(this.schema, entity, groupBy)
 			this.queryWrapper = new LimitByGroupWrapper(
-				[path.getAlias(), groupByColumn],
+				[path.alias, groupByColumn],
 				(orderable, qb) => {
 					if (orderBy.length > 0) {
 						[qb, orderable] = this.orderByBuilder.build(qb, orderable, entity, this.pathFactory.create([]), orderBy)
@@ -76,11 +76,9 @@ export class SelectBuilder {
 			}
 			this.qb = this.qb.limit(input.args.limit, input.args.offset)
 		}
-
-		await promise
 	}
 
-	private async selectInternal(mapper: Mapper, entity: Model.Entity, path: Path, input: ObjectNode) {
+	private selectInternal(mapper: Mapper, entity: Model.Entity, path: Path, input: ObjectNode) {
 		if (!input.fields.find(it => it.name === entity.primary && it.alias === entity.primary)) {
 			input = input.withField(new FieldNode(entity.primary, entity.primary, {}))
 		}
@@ -139,11 +137,9 @@ export class SelectBuilder {
 	}
 
 	private async getColumnValues(columnPath: Path, columnName: string): Promise<Input.PrimaryValue[]> {
-		this.qb = this.qb.select([columnPath.back().getAlias(), columnName], columnPath.getAlias())
+		this.qb = this.qb.select([columnPath.back().alias, columnName], columnPath.alias)
 		const rows = await this.rows
-		const columnAlias = columnPath.getAlias()
-		return rows
-			.map((it): Input.PrimaryValue => it[columnAlias] as Input.PrimaryValue)
-			.filter((val, index, all) => all.indexOf(val) === index)
+		const columnAlias = columnPath.alias
+		return Array.from(new Set(rows.map((it): Input.PrimaryValue => it[columnAlias] as Input.PrimaryValue)))
 	}
 }

package/src/mapper/select/SelectHydrator.ts

@@ -1,14 +1,24 @@
 import { Path } from './Path'
 import { Value } from '@contember/schema'
+import { getFulfilledValues, getRejections } from '../../utils'
+
+type DataPromises = {
+	path: Path
+	parentKeyPath: Path
+	data: Promise<SelectNestedData>
+	defaultValue: SelectNestedDefaultValue
+}
+
+type ResolvedData = {
+	path: Path
+	parentKeyPath: Path
+	data: SelectNestedData
+	defaultValue: SelectNestedDefaultValue
+}
 
 export class SelectHydrator {
 	private columns: Path[] = []
-	private promises: {
-		path: Path
-		parentKeyPath: Path
-		data: PromiseLike<SelectNestedData>
-		defaultValue: SelectNestedDefaultValue
-	}[] = []
+	private promises: DataPromises[] = []
 
 	public addColumn(path: Path) {
 		this.columns.push(path)
@@ -17,21 +27,21 @@ export class SelectHydrator {
 	public addPromise(
 		path: Path,
 		parentKeyPath: Path,
-		data: PromiseLike<SelectNestedData>,
+		data: Promise<SelectNestedData>,
 		defaultValue: SelectNestedDefaultValue,
 	) {
 		this.promises.push({ path, parentKeyPath, data, defaultValue })
 	}
 
 	public async hydrateGroups(rows: SelectRow[], groupBy: string): Promise<SelectGroupedObjects> {
-		await Promise.all(this.promises.map(it => it.data))
+		const resolved = await this.resolveDataPromises()
 		const result: SelectGroupedObjects = {}
 		for (let row of rows) {
 			const key = row[groupBy] as Value.PrimaryValue
 			if (!result[key]) {
 				result[key] = []
 			}
-			result[key].push(await this.hydrateRow(row))
+			result[key].push(this.hydrateRow(row, resolved))
 		}
 		return result
 	}
@@ -43,19 +53,22 @@ export class SelectHydrator {
 		rows: SelectRow[],
 		indexBy?: string,
 	): Promise<SelectResultObject[] | SelectIndexedResultObjects> {
-		await Promise.all(this.promises.map(it => it.data))
+		const resolved = await this.resolveDataPromises()
 		if (indexBy) {
 			const result: SelectIndexedResultObjects = {}
 			for (let row of rows) {
-				result[row[indexBy] as Value.PrimaryValue] = await this.hydrateRow(row)
+				result[row[indexBy] as Value.PrimaryValue] = this.hydrateRow(row, resolved)
 			}
 			return result
 		}
-
-		return Promise.all(rows.map(row => this.hydrateRow(row)))
+		const result: SelectResultObject[] = []
+		for (const row of rows) {
+			result.push(this.hydrateRow(row, resolved))
+		}
+		return result
 	}
 
-	private async hydrateRow(row: SelectRow): Promise<SelectResultObject> {
+	private hydrateRow(row: SelectRow, resolvedData: ResolvedData[]): SelectResultObject {
 		const result: SelectResultObject = {}
 
 		for (let columnPath of this.columns) {
@@ -63,24 +76,44 @@ export class SelectHydrator {
 			const last: string = path.pop() as string
 			const currentObject = path.reduce<any>((obj, part) => (obj[part] = obj[part] || {}), result)
 
-			const field = row[columnPath.getAlias()]
+			const field = row[columnPath.alias]
 			currentObject[last] = this.formatValue(field)
 		}
 
-		for (let { path, parentKeyPath, data, defaultValue } of this.promises) {
-			const awaitedData = await data
+		for (let { path, parentKeyPath, 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.getAlias()] as Value.PrimaryValue
+			const parentValue = row[parentKeyPath.alias] as Value.PrimaryValue
 			if (currentObject) {
-				currentObject[last] = (parentValue ? awaitedData[parentValue] : undefined) || defaultValue
+				currentObject[last] = (parentValue ? data[parentValue] : undefined) || defaultValue
 			}
 		}
 
 		return result
 	}
 
+	private async resolveDataPromises(): Promise<ResolvedData[]> {
+		const results = await Promise.allSettled(this.promises.map(async (it): Promise<ResolvedData> => ({
+			defaultValue: it.defaultValue,
+			parentKeyPath: it.parentKeyPath,
+			path: it.path,
+			data: await it.data,
+		})))
+		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))
+			}
+			throw failures[0]
+		}
+
+		return getFulfilledValues(results)
+	}
+
 	private formatValue(value: any) {
 		if (value instanceof Date) {
 			return value.toISOString()

package/src/mapper/select/WhereBuilder.ts

@@ -48,7 +48,7 @@ export class WhereBuilder {
 		allowManyJoin: boolean,
 		joinList: WhereJoinDefinition[],
 	): SqlConditionBuilder {
-		const tableName = path.getAlias()
+		const tableName = path.alias
 
 		if (where.and !== undefined && where.and.length > 0) {
 			const expr = where.and
@@ -216,7 +216,11 @@ export class WhereBuilder {
 		if (keys.filter(it => !['and', 'or', 'not', primaryField].includes(it)).length > 0) {
 			return null
 		}
-		let condition: Input.Condition<never> = {}
+		let condition: {
+			and?: Array<Input.Condition<never>>
+			or?: Array<Input.Condition<never>>
+			not?: Input.Condition<never>
+		} = {}
 		if (where.and) {
 			const conditions = where.and
 				.filter((it): it is Input.Where => !!it)
@@ -236,11 +240,11 @@ export class WhereBuilder {
 			condition.or = conditions as Input.Condition<never>[]
 		}
 		if (where.not) {
-			const condition = this.transformWhereToPrimaryCondition(where.not, primaryField)
-			if (condition === null) {
+			const conditions = this.transformWhereToPrimaryCondition(where.not, primaryField)
+			if (conditions === null) {
 				return null
 			}
-			condition.not = condition as Input.Condition<never>
+			condition.not = conditions as Input.Condition<never>
 		}
 		if (where[primaryField]) {
 			if (Object.keys(condition).length > 0) {

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

@@ -19,8 +19,8 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 	visitColumn(entity: Model.Entity, column: Model.AnyColumn): void {
 		const columnPath = this.executionContext.path
 		this.executionContext.addColumn(qb => {
-			const tableAlias = columnPath.back().getAlias()
-			const columnAlias = columnPath.getAlias()
+			const tableAlias = columnPath.back().alias
+			const columnAlias = columnPath.alias
 
 			const fieldPredicate = this.predicateFactory.shouldApplyCellLevelPredicate(
 				entity,

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

@@ -48,7 +48,7 @@ export class MetaHandler implements SelectExecutionHandler<{}> {
 							}
 							return condition
 						}),
-					metaPath.getAlias(),
+					metaPath.alias,
 				),
 			)
 		}, metaPath)