@contember/engine-content-api 1.1.0-alpha.6 → 1.1.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.1.0-alpha.6",
+  "version": "1.1.0-beta.0",
   "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.1.0-alpha.6",
-    "@contember/dic": "^1.1.0-alpha.6",
-    "@contember/engine-common": "^1.1.0-alpha.6",
-    "@contember/graphql-utils": "^1.1.0-alpha.6",
-    "@contember/schema": "^1.1.0-alpha.6",
-    "@contember/schema-utils": "^1.1.0-alpha.6",
+    "@contember/database": "^1.1.0-beta.0",
+    "@contember/dic": "^1.1.0-beta.0",
+    "@contember/engine-common": "^1.1.0-beta.0",
+    "@contember/graphql-utils": "^1.1.0-beta.0",
+    "@contember/schema": "^1.1.0-beta.0",
+    "@contember/schema-utils": "^1.1.0-beta.0",
     "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.1.0-alpha.6",
-    "@contember/engine-api-tester": "^1.1.0-alpha.6",
-    "@contember/schema-definition": "^1.1.0-alpha.6",
+    "@contember/database-tester": "^1.1.0-beta.0",
+    "@contember/engine-api-tester": "^1.1.0-beta.0",
+    "@contember/schema-definition": "^1.1.0-beta.0",
     "@graphql-codegen/cli": "^1.15.2",
     "@graphql-codegen/typescript": "^1.15.2",
     "@graphql-codegen/typescript-operations": "^1.15.2",

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/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/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/select/ConditionBuilder.ts

@@ -7,6 +7,7 @@ export class ConditionBuilder {
 		builder: SqlConditionBuilder,
 		tableName: string,
 		columnName: string,
+		columnType: string,
 		condition: Input.Condition<any>,
 	): SqlConditionBuilder {
 		const keys = Object.keys(condition) as (keyof Required<Input.Condition<any>>)[]
@@ -27,13 +28,13 @@ export class ConditionBuilder {
 				param: Exclude<Input.Condition<any>[K], undefined>,
 			) => SqlConditionBuilder
 		} = {
-			and: (builder, expressions) => builder.and(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, expr), builder2)),
-			or: (builder, expressions) => builder.or(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, expr), builder2)),
-			not: (builder, expression) => builder.not(builder2 => this.build(builder2, tableName, columnName, expression)),
+			and: (builder, expressions) => builder.and(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
+			or: (builder, expressions) => builder.or(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
+			not: (builder, expression) => builder.not(builder2 => this.build(builder2, tableName, columnName, columnType, expression)),
 			eq: (builder, value) => builder.compare(columnIdentifier, Operator.eq, value),
 			notEq: (builder, value) => builder.compare(columnIdentifier, Operator.notEq, value),
 			isNull: (builder, value) => value ? builder.isNull(columnIdentifier) : builder.not(clause => clause.isNull(columnIdentifier)),
-			in: (builder, values) => builder.in(columnIdentifier, values),
+			in: (builder, values) => builder.in(columnIdentifier, values, columnType),
 			notIn: (builder, values) => builder.not(builder2 => builder2.in(columnIdentifier, values)),
 			lt: (builder, value) => builder.compare(columnIdentifier, Operator.lt, value),
 			lte: (builder, value) => builder.compare(columnIdentifier, Operator.lte, value),

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/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
@@ -101,6 +101,7 @@ export class WhereBuilder {
 							conditionBuilder,
 							tableName,
 							relation.joiningColumn.columnName,
+							(targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType,
 							primaryCondition,
 						)
 					}
@@ -114,7 +115,7 @@ export class WhereBuilder {
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
 				visitColumn: (entity, column) => {
 					const subWhere: Input.Condition<Input.ColumnValue> = where[column.name] as Input.Condition<Input.ColumnValue>
-					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, subWhere)
+					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column.columnType, subWhere)
 				},
 				visitOneHasOneInverse: joinedWhere,
 				visitOneHasOneOwning: joinedWhere,
@@ -194,8 +195,10 @@ export class WhereBuilder {
 		const primaryCondition = this.transformWhereToPrimaryCondition(relationWhere, targetEntity.primary)
 		if (primaryCondition !== null) {
 
+			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType
+
 			return qb.where(condition =>
-				this.conditionBuilder.build(condition, 'junction_', toColumn, primaryCondition),
+				this.conditionBuilder.build(condition, 'junction_', toColumn, columnType, primaryCondition),
 			)
 		}
 

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)

package/src/resolvers/MutationResolver.ts

@@ -388,12 +388,13 @@ export class MutationResolver {
 		if (errorResponse) {
 			return errorResponse
 		}
-		const primary = getInsertPrimary(result) || getUpdatePrimary(result)
-		if (!primary) {
+		const primary = getInsertPrimary(result)
+		const byResolved = primary ? { [entity.primary]: primary } : input.by
+		if (!byResolved) {
 			throw new ImplementationException('MutationResolver::resolveUpsertInternal does not handle result properly')
 		}
 
-		const nodes = await this.resolveResultNodes(mapper, entity, { [entity.primary]: primary }, queryAst)
+		const nodes = await this.resolveResultNodes(mapper, entity, byResolved, queryAst)
 		return {
 			ok: true,
 			validation: {

package/src/schema/CustomTypesProvider.ts

@@ -1,19 +1,36 @@
 import { GraphQLScalarType, Kind } from 'graphql'
 import { JSONType } from '@contember/graphql-utils'
-import { singletonFactory } from '../utils'
 
-//todo: implement serialize, parseValue and parseLiteral properly
+
+const uuidPattern = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[1-5][0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$/i
+/** dashes are optional */
+const isUuid = (value: string): boolean => {
+	return (
+		value.length <= 36 &&
+		value.length >= 32 &&
+		value.match(uuidPattern) !== null
+	)
+}
 
 export class CustomTypesProvider {
 	public readonly uuidType: GraphQLScalarType = new GraphQLScalarType({
 		name: 'UUID',
 		serialize: str => String(str),
-		parseValue: str => String(str),
+		parseValue: str => {
+			if (typeof str !== 'string' || !isUuid(str)) {
+				return undefined
+			}
+			return str
+		},
 		parseLiteral: function parseLiteral(ast) {
-			return ast.kind === Kind.STRING ? ast.value : undefined
+			if (ast.kind !== Kind.STRING || !isUuid(ast.value)) {
+				return undefined
+			}
+			return ast.value
 		},
 	})
 
+	//todo: implement serialize, parseValue and parseLiteral properly
 	public readonly dateType: GraphQLScalarType = new GraphQLScalarType({
 		name: 'Date',
 		serialize: str => String(str),

package/src/schema/OrderByTypeProvider.ts

@@ -15,6 +15,8 @@ export class OrderByTypeProvider {
 		values: {
 			asc: { value: 'asc' },
 			desc: { value: 'desc' },
+			ascNullsFirst: { value: 'asc nulls first' },
+			descNullsLast: { value: 'desc nulls last' },
 		},
 	})
 

package/tests/cases/integration/graphQlDb/update/invalidInput.test.ts

@@ -41,29 +41,3 @@ test('returns error for invalid date input', async () => {
 		expectDatabase: {},
 	})
 })
-
-test('returns error for invalid uuid', async () => {
-	await executeDbTest({
-		schema,
-		seed: [],
-		query: GQL`mutation {
-        updatePost(by: { id: "abc" }, data: { createdAt: "2020-13-01 20:00" }) {
-          ok
-          errors {
-            type
-            message
-          }
-        }
-      }`,
-		return: response => {
-			assert.ok(response.updatePost)
-			assert.notOk(response.updatePost.ok)
-			assert.lengthOf(response.updatePost.errors, 1)
-			assert.equal(response.updatePost.errors[0].type, 'InvalidDataInput')
-			assert.match(response.updatePost.errors[0].message, /invalid input syntax for (type )?uuid: "abc"/)
-		},
-		expectDatabase: {},
-	})
-})
-
-