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

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

@@ -0,0 +1,58 @@
+export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly (P | boolean | undefined)[]): P | { or?: P[] } | boolean => {
+	const normalized: P[] = []
+	let hasNever = false
+	for (const operand of operands) {
+		if (operand === true) {
+			return true
+		} else if (operand === false) {
+			hasNever = true
+		} else if (operand !== undefined)  {
+			normalized.push(...Array.isArray(operand.or) ? operand.or : [operand])
+		}
+	}
+
+	if (normalized.length > 1) {
+		return { or: normalized }
+	} else if (normalized.length === 1) {
+		return normalized[0]
+	} else if (hasNever) {
+		return false
+	} else {
+		return {}
+	}
+}
+
+export const optimizeAnd = <P extends Record<string, unknown>>(operands: readonly (P | boolean | undefined)[]): P | { and?: P[] } | boolean => {
+	const normalized: P[] = []
+	let hasAlways = false
+
+	for (const operand of operands) {
+		if (operand === true) {
+			hasAlways = true
+		} else if (operand === false) {
+			return false
+		} else if (operand !== undefined) {
+			normalized.push(...Array.isArray(operand.and) ? operand.and : [operand])
+		}
+	}
+
+	if (normalized.length > 1) {
+		return { and: normalized }
+	} else if (normalized.length === 1) {
+		return normalized[0]
+	} else if (hasAlways) {
+		return true
+	} else {
+		return {}
+	}
+}
+
+export const optimizeNot = <P extends Record<string, unknown>>(operand: P | boolean): P['not'] | { not: P } | boolean => {
+	if (typeof operand === 'boolean') {
+		return !operand
+	} else if (operand.not) {
+		return operand.not as P['not']
+	} else {
+		return { not: operand }
+	}
+}

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -26,7 +26,7 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationRes
 		private readonly mapper: Mapper,
 	) {}
 
-	public column({ entity, column }: Context.ColumnContext) {
+	public column({ entity, column }: Model.ColumnContext) {
 		if (this.data[column.name] !== undefined) {
 			this.updateBuilder.addFieldValue(column.name, this.data[column.name] as Value.AtomicValue)
 		}

package/src/mapper/update/UpdateBuilder.ts

@@ -74,9 +74,9 @@ export class UpdateBuilder {
 					const columns = new Set(resolvedData.map(it => it.columnName))
 					const allColumns: string[] = Object.values(
 						acceptEveryFieldVisitor(this.schema, this.entity, {
-							visitColumn: (entity, column) => column.columnName,
-							visitManyHasOne: (entity, relation) => relation.joiningColumn.columnName,
-							visitOneHasOneOwning: (entity, relation) => relation.joiningColumn.columnName,
+							visitColumn: ({ column }) => column.columnName,
+							visitManyHasOne: ({ relation }) => relation.joiningColumn.columnName,
+							visitOneHasOneOwning: ({ relation }) => relation.joiningColumn.columnName,
 							visitManyHasManyInverse: () => null,
 							visitManyHasManyOwning: () => null,
 							visitOneHasOneInverse: () => null,

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -7,7 +7,7 @@ import {
 	GraphQLResolveInfo,
 	isListType,
 	isNonNullType,
-	isObjectType,
+	isObjectType, Kind,
 } from 'graphql'
 import { SelectionSetNode } from 'graphql/language/ast'
 import { getArgumentValues } from 'graphql/execution/values'
@@ -67,13 +67,13 @@ export class GraphQlQueryAstFactory {
 	): AnyNode[] {
 		const fields: ObjectNode | FieldNode[] = []
 		for (const subNode of selectionSet.selections) {
-			if (isIt<GraphQlFieldNode>(subNode, 'kind', 'Field')) {
+			if (isIt<GraphQlFieldNode>(subNode, 'kind', Kind.FIELD)) {
 				const field = this.createFromNode(info, parentType, subNode, path, filter)
 				if (field === null) {
 					continue
 				}
 				fields.push(field)
-			} else if (isIt<FragmentSpreadNode>(subNode, 'kind', 'FragmentSpread')) {
+			} else if (isIt<FragmentSpreadNode>(subNode, 'kind', Kind.FRAGMENT_SPREAD)) {
 				const fragmentDefinition = info.fragments[subNode.name.value]
 				if (!fragmentDefinition) {
 					throw new Error(`GraphQlQueryAstFactory: Fragment definition ${subNode.name.value} not found`)

package/src/resolvers/MutationResolver.ts

@@ -457,7 +457,7 @@ export class MutationResolver {
 				throw new Error('MutationResolver: expected ObjectNode')
 			}
 			const objectWithArgs = singleNodeQuery.withArgs({ by: where })
-			nodes[singleNodeQuery.alias] = await mapper.selectUnique(entity, objectWithArgs)
+			nodes[singleNodeQuery.alias] = await mapper.selectUnique(entity, objectWithArgs, [])
 		}
 		return nodes
 	}

package/src/resolvers/ReadHelpers.ts

@@ -15,7 +15,7 @@ export const paginate = async (
 	const totalCount = paginationHelper.requiresTotalCount
 		? await mapper.count(entity, queryAst.args.filter || {})
 		: undefined
-	const nodes = paginationHelper.nodeField ? await mapper.select(entity, paginationHelper.nodeField) : undefined
+	const nodes = paginationHelper.nodeField ? await mapper.select(entity, paginationHelper.nodeField, []) : undefined
 
 	return paginationHelper.createResponse(totalCount, nodes)
 }
@@ -37,9 +37,9 @@ export const executeReadOperations = async (
 		trxResult[field.alias] = await (() => {
 			switch (meta.operation) {
 				case Operation.get:
-					return mapper.selectUnique(meta.entity, field)
+					return mapper.selectUnique(meta.entity, field, [])
 				case Operation.list:
-					return mapper.select(meta.entity, field)
+					return mapper.select(meta.entity, field, [])
 				case Operation.paginate:
 					return paginate(mapper, meta.entity, field)
 				case Operation.create:

package/src/resolvers/ReadResolver.ts

@@ -33,12 +33,12 @@ export class ReadResolver {
 
 	public async resolveListQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.ListQueryInput> = this.queryAstFactory.create(info)
-		return await this.mapperFactory(this.db).select(entity, queryAst)
+		return await this.mapperFactory(this.db).select(entity, queryAst, [])
 	}
 
 	public async resolveGetQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.UniqueQueryInput> = this.queryAstFactory.create(info)
-		return await this.mapperFactory(this.db).selectUnique(entity, queryAst)
+		return await this.mapperFactory(this.db).selectUnique(entity, queryAst, [])
 	}
 
 	public async resolvePaginationQuery(entity: Model.Entity, info: GraphQLResolveInfo) {

package/src/schema/FieldAccessVisitor.ts

@@ -7,11 +7,11 @@ export class FieldAccessVisitor implements Model.ColumnVisitor<boolean>, Model.R
 		private readonly authorizator: Authorizator,
 	) {}
 
-	visitColumn(entity: Model.Entity, column: Model.AnyColumn) {
+	visitColumn({ column, entity }: Model.ColumnContext) {
 		return this.authorizator.getFieldPermissions(this.operation, entity.name, column.name) !== 'no'
 	}
 
-	visitRelation({}, {}, targetEntity: Model.Entity) {
+	visitRelation({ targetEntity }: Model.AnyRelationContext) {
 		return this.authorizator.getEntityPermission(this.operation, targetEntity.name) !== 'no'
 	}
 }

package/src/schema/OrderByTypeProvider.ts

@@ -51,7 +51,7 @@ export class OrderByTypeProvider {
 
 			const field = acceptFieldVisitor(this.schema, name, fieldName, {
 				visitColumn: () => ({ type: this.orderDirectionEnum }),
-				visitHasOne: (entity, relation) => ({ type: this.getEntityOrderByType(relation.target) }),
+				visitHasOne: ({ relation }) => ({ type: this.getEntityOrderByType(relation.target) }),
 				visitHasMany: () => undefined,
 			} as Model.FieldVisitor<GraphQLInputFieldConfig | undefined>)
 

package/src/schema/WhereTypeProvider.ts

@@ -74,7 +74,7 @@ export class WhereTypeProvider {
 					continue
 				}
 				fields[field] = acceptFieldVisitor<GraphQLInputFieldConfig>(this.schema, entity, field, {
-					visitRelation: (entity, relation, targetEntity) => {
+					visitRelation: ({ targetEntity }) => {
 						// if (!isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn')) {
 						// 	throw new Error('Only column or owning relation can be a part of unique key')
 						// }
@@ -84,7 +84,7 @@ export class WhereTypeProvider {
 						}
 						return { type: uniqueWhere }
 					},
-					visitColumn: (entity, column) => ({ type: this.columnTypeResolver.getType(column) }),
+					visitColumn: ({ column }) => ({ type: this.columnTypeResolver.getType(column) }),
 				})
 			}
 		}
@@ -104,8 +104,8 @@ export class WhereTypeProvider {
 				continue
 			}
 			fields[fieldName] = acceptFieldVisitor(this.schema, name, fieldName, {
-				visitColumn: (entity, column) => ({ type: this.conditionTypeProvider.getCondition(column) }),
-				visitRelation: (entity, relation) => ({ type: this.getEntityWhereType(relation.target) }),
+				visitColumn: ({ column }) => ({ type: this.conditionTypeProvider.getCondition(column) }),
+				visitRelation: ({ relation }) => ({ type: this.getEntityWhereType(relation.target) }),
 			} as Model.FieldVisitor<GraphQLInputFieldConfig>)
 		}
 

package/src/schema/entities/FieldArgsVisitor.ts

@@ -15,11 +15,11 @@ export class FieldArgsVisitor implements
 		this.whereTypeProvider = whereTypeProvider
 	}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn) {
+	public visitColumn() {
 		return undefined
 	}
 
-	public visitHasMany(entity: Model.Entity, relation: Model.Relation) {
+	public visitHasMany({ relation }: Model.AnyHasManyRelationContext) {
 		const filter = this.getWhereArg(relation)
 		const orderBy = this.getOrderByArgs(relation)
 		return {
@@ -30,7 +30,7 @@ export class FieldArgsVisitor implements
 		}
 	}
 
-	public visitHasOne(entity: Model.Entity, relation: Model.Relation) {
+	public visitHasOne({ relation }: Model.ManyHasOneContext) {
 		const filter = this.getWhereArg(relation)
 		return { filter }
 	}

package/src/schema/entities/FieldTypeVisitor.ts

@@ -13,7 +13,7 @@ export class FieldTypeVisitor implements Model.ColumnVisitor<GraphQLOutputType>,
 	) {
 	}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): GraphQLOutputType {
+	public visitColumn({ column, entity }: Model.ColumnContext): GraphQLOutputType {
 		const basicType = this.columnTypeResolver.getType(column)
 		const fieldPredicate = this.authorizator.getFieldPredicate(Acl.Operation.read, entity.name, column.name)
 		const idPredicate = this.authorizator.getFieldPredicate(Acl.Operation.read, entity.name, entity.primary)
@@ -26,12 +26,12 @@ export class FieldTypeVisitor implements Model.ColumnVisitor<GraphQLOutputType>,
 		return basicType
 	}
 
-	public visitHasMany(entity: Model.Entity, relation: Model.Relation): GraphQLOutputType {
+	public visitHasMany({ relation }: Model.AnyHasManyRelationContext): GraphQLOutputType {
 		const entityType = this.entityTypeProvider.getEntity(relation.target)
 		return new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(entityType)))
 	}
 
-	public visitHasOne(entity: Model.Entity, relation: Model.Relation & Model.NullableRelation): GraphQLOutputType {
+	public visitHasOne({ relation }: Model.AnyHasOneRelationContext): GraphQLOutputType {
 		return this.entityTypeProvider.getEntity(relation.target)
 	}
 }

package/src/schema/mutations/CreateEntityInputFieldVisitor.ts

@@ -15,7 +15,7 @@ export class CreateEntityInputFieldVisitor implements
 		private readonly createEntityRelationInputProvider: CreateEntityRelationInputProvider,
 	) {}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): GraphQLInputFieldConfig | undefined {
+	public visitColumn({ entity, column }: Model.ColumnContext): GraphQLInputFieldConfig | undefined {
 		if (entity.primary === column.name && !this.authorizator.isCustomPrimaryAllowed(entity.name)) {
 			return undefined
 		}
@@ -28,10 +28,7 @@ export class CreateEntityInputFieldVisitor implements
 		}
 	}
 
-	public visitHasOne(
-		entity: Model.Entity,
-		relation: Model.Relation & Model.NullableRelation,
-	): GraphQLInputFieldConfig | undefined {
+	public visitHasOne({ entity, relation }: Model.AnyHasOneRelationContext): GraphQLInputFieldConfig | undefined {
 		const type = this.createEntityRelationInputProvider.getCreateEntityRelationInput(entity.name, relation.name)
 		if (type === undefined) {
 			return undefined
@@ -41,7 +38,7 @@ export class CreateEntityInputFieldVisitor implements
 		}
 	}
 
-	public visitHasMany(entity: Model.Entity, relation: Model.Relation): GraphQLInputFieldConfig | undefined {
+	public visitHasMany({ entity, relation }: Model.AnyHasManyRelationContext): GraphQLInputFieldConfig | undefined {
 		const type = this.createEntityRelationInputProvider.getCreateEntityRelationInput(entity.name, relation.name)
 		if (type === undefined) {
 			return undefined

package/src/schema/mutations/CreateEntityRelationAllowedOperationsVisitor.ts

@@ -12,32 +12,23 @@ export class CreateEntityRelationAllowedOperationsVisitor implements
 		throw new ImplementationException('CreateEntityRelationAllowedOperationsVisitor: Not applicable for a column')
 	}
 
-	public visitManyHasManyInverse({}, {}, targetEntity: Model.Entity, targetRelation: Model.ManyHasManyOwningRelation) {
+	public visitManyHasManyInverse({ targetEntity, targetRelation }: Model.ManyHasManyInverseContext) {
 		return this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-	) {
+	public visitManyHasManyOwning({ entity, targetEntity, relation }: Model.ManyHasManyOwningContext) {
 		return this.getAllowedOperations(targetEntity, entity, relation)
 	}
 
-	public visitOneHasMany({}, {}, targetEntity: Model.Entity, targetRelation: Model.ManyHasOneRelation) {
+	public visitOneHasMany({ targetEntity, targetRelation }: Model.OneHasManyContext) {
 		return this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity) {
+	public visitManyHasOne({ targetEntity, entity, relation }: Model.ManyHasOneContext) {
 		return this.getAllowedOperations(targetEntity, entity, relation)
 	}
 
-	public visitOneHasOneInverse(
-		{},
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	) {
+	public visitOneHasOneInverse({ targetEntity, targetRelation, relation }: Model.OneHasOneInverseContext) {
 		const operations = this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 		if (relation.nullable || targetRelation.nullable) {
 			return operations
@@ -45,12 +36,7 @@ export class CreateEntityRelationAllowedOperationsVisitor implements
 		return operations.filter(it => it === Input.CreateRelationOperation.create)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	) {
+	public visitOneHasOneOwning({ targetEntity, entity, relation, targetRelation }: Model.OneHasOneOwningContext) {
 		const operations = this.getAllowedOperations(targetEntity, entity, relation)
 		if (!targetRelation || targetRelation.nullable || relation.nullable) {
 			return operations

package/src/schema/mutations/CreateEntityRelationInputFieldVisitor.ts

@@ -26,29 +26,16 @@ export class CreateEntityRelationInputFieldVisitor implements
 		throw new ImplementationException('CreateEntityRelationInputFieldVisitor: Not applicable for a column')
 	}
 
-	public visitHasOne(
-		entity: Model.Entity,
-		relation: Model.Relation & Model.NullableRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
-	): GraphQLInputObjectType | undefined {
-		return this.createInputObject(entity, relation, targetEntity, targetRelation, false)
+	public visitHasOne(context: Model.ManyHasOneContext): GraphQLInputObjectType | undefined {
+		return this.createInputObject(context, false)
 	}
 
-	public visitHasMany(
-		entity: Model.Entity,
-		relation: Model.Relation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
-	): GraphQLInputObjectType | undefined {
-		return this.createInputObject(entity, relation, targetEntity, targetRelation, true)
+	public visitHasMany(context: Model.OneHasManyContext): GraphQLInputObjectType | undefined {
+		return this.createInputObject(context, true)
 	}
 
 	public createInputObject(
-		entity: Model.Entity,
-		relation: Model.Relation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
+		{ entity, relation, targetEntity, targetRelation }: Model.AnyRelationContext,
 		withAliasField: boolean,
 	): GraphQLInputObjectType | undefined {
 		const targetName = targetRelation ? targetRelation.name : undefined

package/src/schema/mutations/UpdateEntityInputFieldVisitor.ts

@@ -14,7 +14,7 @@ export class UpdateEntityInputFieldVisitor implements
 		private readonly updateEntityRelationInputProvider: UpdateEntityRelationInputProvider,
 	) {}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): GraphQLInputFieldConfig | undefined {
+	public visitColumn({ entity, column }: Model.ColumnContext) {
 		if (entity.primary === column.name) {
 			return undefined
 		}
@@ -27,10 +27,7 @@ export class UpdateEntityInputFieldVisitor implements
 		}
 	}
 
-	public visitHasOne(
-		entity: Model.Entity,
-		relation: Model.Relation & Model.NullableRelation,
-	): GraphQLInputFieldConfig | undefined {
+	public visitHasOne({ entity, relation }: Model.AnyHasOneRelationContext) {
 		const type = this.updateEntityRelationInputProvider.getUpdateEntityRelationInput(entity.name, relation.name)
 		if (type === undefined) {
 			return undefined
@@ -40,7 +37,7 @@ export class UpdateEntityInputFieldVisitor implements
 		}
 	}
 
-	public visitHasMany(entity: Model.Entity, relation: Model.Relation): GraphQLInputFieldConfig | undefined {
+	public visitHasMany({ entity, relation }: Model.AnyHasManyRelationContext) {
 		const type = this.updateEntityRelationInputProvider.getUpdateEntityRelationInput(entity.name, relation.name)
 		if (type === undefined) {
 			return undefined

package/src/schema/mutations/UpdateEntityRelationAllowedOperationsVisitor.ts

@@ -11,23 +11,19 @@ export class UpdateEntityRelationAllowedOperationsVisitor implements
 		throw new Error('UpdateEntityRelationAllowedOperationsVisitor: Not applicable for a column')
 	}
 
-	public visitManyHasManyInverse({}, {}, targetEntity: Model.Entity, targetRelation: Model.ManyHasManyOwningRelation) {
+	public visitManyHasManyInverse({ targetEntity, targetRelation }: Model.ManyHasManyInverseContext) {
 		return this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-	) {
+	public visitManyHasManyOwning({ entity, targetEntity, relation }: Model.ManyHasManyOwningContext) {
 		return this.getAllowedOperations(targetEntity, entity, relation)
 	}
 
-	public visitOneHasMany({}, {}, targetEntity: Model.Entity, targetRelation: Model.ManyHasOneRelation) {
+	public visitOneHasMany({ targetRelation, targetEntity }: Model.OneHasManyContext) {
 		return this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity) {
+	public visitManyHasOne({ targetEntity, relation, entity }: Model.ManyHasOneContext) {
 		const operations = this.getAllowedOperations(targetEntity, entity, relation)
 		if (relation.nullable) {
 			return operations
@@ -39,12 +35,7 @@ export class UpdateEntityRelationAllowedOperationsVisitor implements
 		return operations.filter(it => !forbiddenOperations.includes(it))
 	}
 
-	public visitOneHasOneInverse(
-		{},
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	) {
+	public visitOneHasOneInverse({ relation, targetEntity, targetRelation }: Model.OneHasOneInverseContext) {
 		const operations = this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 		if (relation.nullable || targetRelation.nullable) {
 			return operations
@@ -52,12 +43,7 @@ export class UpdateEntityRelationAllowedOperationsVisitor implements
 		return operations.filter(it => it === Input.UpdateRelationOperation.update)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	) {
+	public visitOneHasOneOwning({ targetEntity, entity, relation, targetRelation }: Model.OneHasOneOwningContext) {
 		const operations = this.getAllowedOperations(targetEntity, entity, relation)
 		if (relation.nullable || !targetRelation || targetRelation.nullable) {
 			return operations

package/src/schema/mutations/UpdateEntityRelationInputFieldVisitor.ts

@@ -27,12 +27,7 @@ export class UpdateEntityRelationInputFieldVisitor implements
 		throw new Error('UpdateEntityRelationInputFieldVisitor: Not applicable for a column')
 	}
 
-	public visitHasOne(
-		entity: Model.Entity,
-		relation: Model.Relation & Model.NullableRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
-	): GraphQLInputObjectType | undefined {
+	public visitHasOne({ targetRelation, targetEntity, relation, entity }: Model.AnyHasOneRelationContext) {
 		const withoutRelation = targetRelation ? targetRelation.name : undefined
 
 		const whereInput = this.createWhereInput(targetEntity)
@@ -84,12 +79,7 @@ export class UpdateEntityRelationInputFieldVisitor implements
 		})
 	}
 
-	public visitHasMany(
-		entity: Model.Entity,
-		relation: Model.Relation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
-	): GraphQLInputObjectType | undefined {
+	public visitHasMany({ entity, relation, targetEntity, targetRelation }: Model.AnyHasManyRelationContext) {
 		const withoutRelation = targetRelation ? targetRelation.name : undefined
 
 		const whereInput = this.createWhereInput(targetEntity)

package/src/utils/object.ts

@@ -9,18 +9,18 @@ function filterObject<Input extends {}, Result extends { [Key in keyof Input]: I
 	object: Input,
 	callback: TypeGuard<Input, Result> | Filter<Input>,
 ): Result {
-	return (Object.entries(object) as any)
-		.filter(<K extends keyof Input>(it: [K, Input[K]]): it is [K, Result[K]] =>
-			(callback as any)(it[0] as K, it[1] as Input[K], object),
-		)
-		.reduce((result: Result, [key, value]: [string, any]) => ({ ...(result as any), [key]: value }), {} as Result)
+	return Object.fromEntries(Object.entries(object)
+		.filter(([key, value]) => (callback as any)(key, value, object)),
+	) as Result
 }
 
 function mapObject<Input, Result>(
 	input: { [key: string]: Input },
 	callback: (value: Input, key: string) => Result,
 ): { [key: string]: Result } {
-	return Object.keys(input).reduce((acc, key) => ({ ...acc, [key]: callback(input[key], key) }), {})
+	return Object.fromEntries(
+		Object.entries(input).map(([key, value]) => [key, callback(value, key)]),
+	)
 }
 
 export { filterObject, mapObject }

package/src/utils/uniqueWhereFields.ts

@@ -8,10 +8,10 @@ export const getFieldsForUniqueWhere = (schema: Model.Schema, entity: Model.Enti
 			visitColumn: () => undefined,
 			visitManyHasManyInverse: () => undefined,
 			visitManyHasManyOwning: () => undefined,
-			visitOneHasMany: ({}, relation) => [relation.name],
+			visitOneHasMany: ({ relation }) => [relation.name],
 			visitManyHasOne: () => undefined,
-			visitOneHasOneInverse: ({}, relation) => [relation.name],
-			visitOneHasOneOwning: ({}, relation) => [relation.name],
+			visitOneHasOneInverse: ({ relation }) => [relation.name],
+			visitOneHasOneOwning: ({ relation }) => [relation.name],
 		}),
 	).filter((it): it is [string] => !!it)
 

package/tests/cases/integration/graphQlDb/insert/insertSequence.test.ts

@@ -0,0 +1,34 @@
+import { SchemaDefinition as def } from '@contember/schema-definition'
+import { GQL } from '../../../../src/tags'
+import { test } from 'vitest'
+import { executeDbTest } from '@contember/engine-api-tester'
+
+namespace SeqModel {
+	export class Order {
+		seqId = def.intColumn().sequence().notNull()
+	}
+}
+
+test('insert author with id', async () => {
+	const schema = def.createModel(SeqModel)
+	await executeDbTest({
+		schema: schema,
+		query: GQL`
+          mutation {
+              createOrder(data: {}) {
+                  node {
+                  	seqId
+                  }
+              }
+          }`,
+		seed: [],
+		return: {
+			createOrder: {
+				node: {
+					seqId: 1,
+				},
+			},
+		},
+	})
+})
+

package/tests/cases/integration/graphQlRequests/delete/aclDelete.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'vitest'
 import { execute, sqlDeferred, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Model } from '@contember/schema'
+import { Acl, Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../src/tags'
 import { testUuid } from '../../../../src/testUuid'
 
@@ -32,7 +32,7 @@ test('delete post with acl', async () => {
 			},
 		},
 		variables: {
-			locale_variable: ['cs'],
+			locale_variable: { in: ['cs'] },
 		},
 		executes: [
 			...sqlTransaction([

package/tests/cases/integration/graphQlRequests/insert/acl/setField.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'vitest'
 import { execute, failedTransaction, sqlTransaction } from '../../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Model } from '@contember/schema'
+import { Acl, Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../../src/tags'
 import { testUuid } from '../../../../../src/testUuid'
 
@@ -34,7 +34,7 @@ test('set a name - allowed', async () => {
 			},
 		},
 		variables: {
-			name_variable: ['John', 'Jack'],
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...sqlTransaction([
@@ -89,7 +89,7 @@ test('set a name - denied', async () => {
 			},
 		},
 		variables: {
-			name_variable: ['John', 'Jack'],
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...failedTransaction([

package/tests/cases/integration/graphQlRequests/insert/aclInsert.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'vitest'
 import { execute, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Model } from '@contember/schema'
+import { Acl, Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../src/tags'
 import { testUuid } from '../../../../src/testUuid'
 
@@ -27,7 +27,7 @@ test('insert author (with acl)', async () => {
 			},
 		},
 		variables: {
-			name_variable: ['John', 'Jack'],
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		query: GQL`
         mutation {