@contember/engine-content-api 1.2.0-alpha.3 → 1.2.0-alpha.6

package/src/mapper/select/RelationFetcher.ts

@@ -12,6 +12,52 @@ import { Mapper } from '../Mapper'
 
 export type GroupedCounts = Record<Input.PrimaryValue, number>
 
+type CountOneHasManyGroupsArgs = {
+	mapper: Mapper
+	filter: Input.OptionalWhere | undefined
+	targetEntity: Model.Entity
+	targetRelation: Model.ManyHasOneRelation
+	ids: Input.PrimaryValue[]
+}
+
+type FetchOneHasManyGroupsArgs = {
+	mapper: Mapper
+	objectNode: ObjectNode<Input.ListQueryInput>
+	targetEntity: Model.Entity
+	relation: Model.OneHasManyRelation
+	targetRelation: Model.ManyHasOneRelation
+	ids: Input.PrimaryValue[]
+}
+
+type ManyHasManyBaseArgs =
+	& {
+		mapper: Mapper
+		targetEntity: Model.Entity
+		ids: Input.PrimaryValue[]
+	} & (
+		| {
+			directionFrom: 'owning'
+			sourceRelation: Model.ManyHasManyOwningRelation
+			targetRelation: Model.ManyHasManyInverseRelation | null
+		}
+		| {
+			directionFrom: 'inverse'
+			sourceRelation: Model.ManyHasManyInverseRelation
+			targetRelation: Model.ManyHasManyOwningRelation
+		}
+	)
+type CountManyHasManyGroupArgs =
+	& ManyHasManyBaseArgs
+	& {
+		filter: Input.OptionalWhere | undefined
+	}
+
+type FetchManyHasManyGroupsArgs =
+	& ManyHasManyBaseArgs
+	& {
+		field: ObjectNode<Input.ListQueryInput>
+	}
+
 export class RelationFetcher {
 	constructor(
 		private readonly whereBuilder: WhereBuilder,
@@ -20,25 +66,25 @@ export class RelationFetcher {
 		private readonly pathFactory: PathFactory,
 	) {}
 
-	public async countOneHasManyGroups(
-		mapper: Mapper,
-		filter: Input.OptionalWhere | undefined,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-		ids: Input.PrimaryValue[],
-	): Promise<GroupedCounts> {
+	public async countOneHasManyGroups({
+		mapper,
+		filter,
+		targetEntity,
+		targetRelation,
+		ids,
+	}: CountOneHasManyGroupsArgs): Promise<GroupedCounts> {
 		const filterWithParent = this.createOneHasManyFilter(targetEntity, targetRelation, ids, filter)
 		return mapper.countGrouped(targetEntity, filterWithParent, targetRelation)
 	}
 
-	public async fetchOneHasManyGroups(
-		mapper: Mapper,
-		objectNode: ObjectNode<Input.ListQueryInput>,
-		targetEntity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetRelation: Model.ManyHasOneRelation,
-		ids: Input.PrimaryValue[],
-	): Promise<SelectGroupedObjects> {
+	public async fetchOneHasManyGroups({
+		mapper,
+		objectNode,
+		targetEntity,
+		relation,
+		targetRelation,
+		ids,
+	}: FetchOneHasManyGroupsArgs): Promise<SelectGroupedObjects> {
 		const filter = this.createOneHasManyFilter(targetEntity, targetRelation, ids, objectNode.args.filter)
 		const objectNodeWithWhere = objectNode.withArg<Input.ListQueryInput>('filter', filter)
 		const objectNodeWithOrder = OrderByHelper.appendDefaultOrderBy(
@@ -65,14 +111,17 @@ export class RelationFetcher {
 		}
 	}
 
-	public async countManyHasManyGroups(
-		mapper: Mapper,
-		filter: Input.OptionalWhere | undefined,
-		targetEntity: Model.Entity,
-		owningRelation: Model.ManyHasManyOwningRelation,
-		ids: Input.PrimaryValue[],
-		joiningColumns: JoiningColumns,
-	): Promise<GroupedCounts> {
+	public async countManyHasManyGroups({
+		mapper,
+		filter,
+		targetEntity,
+		directionFrom,
+		sourceRelation,
+		targetRelation,
+		ids,
+	}: CountManyHasManyGroupArgs): Promise<GroupedCounts> {
+		const owningRelation = directionFrom === 'owning' ? sourceRelation : targetRelation
+		const joiningColumns = this.resolveJoiningColumns({ directionFrom, owningRelation })
 		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, targetEntity, { filter })
 			.select(['junction_', joiningColumns.sourceColumn.columnName])
 			.select(expr => expr.raw('count(*)'), 'row_count')
@@ -85,16 +134,18 @@ export class RelationFetcher {
 		return Object.fromEntries(result)
 	}
 
-	public async fetchManyHasManyGroups(
-		mapper: Mapper,
-		field: ObjectNode<Input.ListQueryInput>,
-		targetEntity: Model.Entity,
-		fromRelation: Model.ManyHasManyOwningRelation | Model.ManyHasManyInverseRelation,
-		owningRelation: Model.ManyHasManyOwningRelation,
-		joiningColumns: JoiningColumns,
-		ids: Input.PrimaryValue[],
-	): Promise<SelectGroupedObjects> {
-		const defaultOrderBy = fromRelation.orderBy || []
+	public async fetchManyHasManyGroups({
+		mapper,
+		field,
+		sourceRelation,
+		targetEntity,
+		targetRelation,
+		directionFrom,
+		ids,
+	}: FetchManyHasManyGroupsArgs): Promise<SelectGroupedObjects> {
+		const owningRelation = directionFrom === 'owning' ? sourceRelation : targetRelation
+		const joiningColumns = this.resolveJoiningColumns({ directionFrom, owningRelation })
+		const defaultOrderBy = sourceRelation.orderBy || []
 		const objectNode = OrderByHelper.appendDefaultOrderBy(targetEntity, field, defaultOrderBy)
 
 		const junctionValues = await this.fetchJunction(
@@ -122,11 +173,21 @@ export class RelationFetcher {
 				},
 			})
 			.withField(primaryField)
-		const result = await mapper.select(targetEntity, queryWithWhere)
+		const result = await mapper.select(targetEntity, queryWithWhere, targetRelation)
 
 		return this.buildManyHasManyGroups(targetEntity, joiningColumns, result, junctionValues)
 	}
 
+	private resolveJoiningColumns({ directionFrom, owningRelation }: { owningRelation: Model.ManyHasManyOwningRelation; directionFrom: 'owning' | 'inverse' }): JoiningColumns {
+		return directionFrom === 'owning' ? {
+			sourceColumn: owningRelation.joiningTable.joiningColumn,
+			targetColumn: owningRelation.joiningTable.inverseJoiningColumn,
+		} : {
+			sourceColumn: owningRelation.joiningTable.inverseJoiningColumn,
+			targetColumn: owningRelation.joiningTable.joiningColumn,
+		}
+	}
+
 	private buildManyHasManyGroups(
 		entity: Model.Entity,
 		joiningColumns: JoiningColumns,

package/src/mapper/select/WhereBuilder.ts

@@ -5,6 +5,7 @@ import { Path, PathFactory } from './Path'
 import { JoinBuilder } from './JoinBuilder'
 import { ConditionBuilder } from './ConditionBuilder'
 import { ConditionBuilder as SqlConditionBuilder, Operator, QueryBuilder, SelectBuilder } from '@contember/database'
+import { WhereOptimizer } from './optimizer/WhereOptimizer'
 
 export class WhereBuilder {
 	constructor(
@@ -12,6 +13,7 @@ export class WhereBuilder {
 		private readonly joinBuilder: JoinBuilder,
 		private readonly conditionBuilder: ConditionBuilder,
 		private readonly pathFactory: PathFactory,
+		private readonly whereOptimizer: WhereOptimizer,
 	) {}
 
 	public build(
@@ -31,9 +33,10 @@ export class WhereBuilder {
 		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
 		allowManyJoin: boolean = false,
 	) {
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity)
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildInternal(clause, entity, path, where, allowManyJoin, joinList))
+		const qbWithWhere = callback(clause => this.buildInternal(clause, entity, path, optimizedWhere, allowManyJoin, joinList))
 		return joinList.reduce<SelectBuilder<SelectBuilder.Result>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join(qb, path, entity, relationName),
 			qbWithWhere,
@@ -44,7 +47,7 @@ export class WhereBuilder {
 		conditionBuilder: SqlConditionBuilder,
 		entity: Model.Entity,
 		path: Path,
-		where: Input.OptionalWhere,
+		where: Input.Where,
 		allowManyJoin: boolean,
 		joinList: WhereJoinDefinition[],
 	): SqlConditionBuilder {

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

@@ -4,7 +4,6 @@ import { RelationFetcher } from '../RelationFetcher'
 import { SelectExecutionHandlerContext } from '../SelectExecutionHandler'
 import { PredicateFactory } from '../../../acl'
 import { WhereBuilder } from '../WhereBuilder'
-import { JoiningColumns } from '../../types'
 
 export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.ColumnVisitor<void> {
 	constructor(
@@ -56,11 +55,6 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyOwningRelation,
 	): void {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.inverseJoiningColumn,
-			targetColumn: joiningTable.joiningColumn,
-		}
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
@@ -69,13 +63,15 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 			entity.primary,
 			async ids =>
 				this.relationFetcher.fetchManyHasManyGroups(
-					this.mapper,
-					field,
-					targetEntity,
-					relation,
-					targetRelation,
-					columns,
-					ids,
+					{
+						mapper: this.mapper,
+						field: field,
+						targetEntity: targetEntity,
+						sourceRelation: relation,
+						targetRelation,
+						directionFrom: 'inverse',
+						ids: ids,
+					},
 				),
 			[],
 		)
@@ -85,12 +81,8 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		entity: Model.Entity,
 		relation: Model.ManyHasManyOwningRelation,
 		targetEntity: Model.Entity,
+		targetRelation: Model.ManyHasManyInverseRelation | null,
 	): void {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
@@ -99,7 +91,15 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		this.executionContext.addData(
 			entity.primary,
 			async ids =>
-				this.relationFetcher.fetchManyHasManyGroups(this.mapper, field, targetEntity, relation, relation, columns, ids),
+				this.relationFetcher.fetchManyHasManyGroups({
+					mapper: this.mapper,
+					field: field,
+					targetEntity: targetEntity,
+					sourceRelation: relation,
+					targetRelation,
+					directionFrom: 'owning',
+					ids: ids,
+				}),
 			[],
 		)
 	}
@@ -118,7 +118,14 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		this.executionContext.addData(
 			entity.primary,
 			async ids =>
-				this.relationFetcher.fetchOneHasManyGroups(this.mapper, field, targetEntity, relation, targetRelation, ids),
+				this.relationFetcher.fetchOneHasManyGroups({
+					mapper: this.mapper,
+					objectNode: field,
+					targetEntity: targetEntity,
+					relation: relation,
+					targetRelation: targetRelation,
+					ids: ids,
+				}),
 			[],
 		)
 	}
@@ -148,7 +155,7 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = field.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation.name)
+				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetRelation.name)
 			},
 			null,
 		)
@@ -177,13 +184,13 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetEntity.primary)
+				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetEntity.primary)
 			},
 			null,
 		)
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity): void {
+	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity, targetRelation: Model.OneHasManyRelation | null): void {
 		this.executionContext.addData(
 			relation.name,
 			async ids => {
@@ -201,7 +208,7 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetEntity.primary)
+				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetEntity.primary)
 			},
 			null,
 		)

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

@@ -0,0 +1,35 @@
+import { Input } from '@contember/schema'
+import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
+
+type ObjectEntry<T> = { [K in keyof Required<T>]: [K, T[K]] }[keyof T]
+
+export class ConditionOptimizer {
+	public optimize(condition: Input.Condition): Omit<Input.Condition, 'always' | 'never'> | boolean {
+		if (condition.never) {
+			return false
+		}
+
+		return optimizeAnd(
+			(Object.entries(condition) as ObjectEntry<typeof condition>[]).map(([key, value]) => {
+				if (value === undefined || value === null) {
+					return undefined
+
+				} else if (key === 'always') {
+					return true
+
+				} else if (key === 'and') {
+					return optimizeAnd(value.map(it => this.optimize(it)))
+
+				} else if (key === 'or') {
+					return optimizeOr(value.map(it => this.optimize(it)))
+
+				} else if (key === 'not') {
+					return optimizeNot(this.optimize(value))
+
+				} else {
+					return { [key]: value }
+				}
+			}),
+		)
+	}
+}

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

@@ -0,0 +1,67 @@
+import { Input, Model } from '@contember/schema'
+import { ConditionOptimizer } from './ConditionOptimizer'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
+
+export class WhereOptimizer {
+	constructor(
+		private readonly model: Model.Schema,
+		private readonly conditionOptimizer: ConditionOptimizer,
+	) {
+	}
+
+	public optimize(where: Input.OptionalWhere, entity: Model.Entity): Input.Where {
+		const result = this.optimizeWhere(where, entity)
+
+		if (typeof result === 'boolean') {
+			return { [entity.primary]: { [result ? 'always' : 'never']: true } }
+		}
+
+		return result
+	}
+
+	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity): Input.Where | boolean {
+		return optimizeAnd(
+			Object.entries(where).map(([key, value]) => {
+				if (value === undefined || value === null) {
+					return undefined
+
+				} else if (key === 'and') {
+					return optimizeAnd((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity)))
+
+				} else if (key === 'or') {
+					return optimizeOr((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity)))
+
+				} else if (key === 'not') {
+					return optimizeNot(this.optimizeWhere(value as Input.Where, entity))
+
+				} else {
+					return this.resolveFieldValue(entity, key, value)
+				}
+			}),
+		)
+	}
+
+	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string]) {
+		return acceptFieldVisitor<Input.Where | boolean>(this.model, entity, key, {
+			visitColumn: () => {
+				const optimizedCondition = this.conditionOptimizer.optimize(value as Input.Condition)
+
+				if (typeof optimizedCondition === 'boolean') {
+					return optimizedCondition
+				}
+
+				return { [key]: optimizedCondition }
+			},
+			visitRelation: (entity, relation, targetEntity) => {
+				const optimizedWhere = this.optimizeWhere(value as Input.Where, targetEntity)
+
+				if (typeof optimizedWhere === 'boolean') {
+					return optimizedWhere
+				}
+
+				return { [key]: optimizedWhere }
+			},
+		})
+	}
+}

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

@@ -0,0 +1,54 @@
+export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly (P | boolean)[]): P | { or?: P[] } | boolean => {
+	const normalized: P[] = []
+
+	for (const operand of operands) {
+		if (operand === true) {
+			return true
+		} else if (operand !== false) {
+			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 {
+		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/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, null)
 		}
 		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, null) : 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, null)
 				case Operation.list:
-					return mapper.select(meta.entity, field)
+					return mapper.select(meta.entity, field, null)
 				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, null)
 	}
 
 	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, null)
 	}
 
 	public async resolvePaginationQuery(entity: Model.Entity, info: GraphQLResolveInfo) {

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

@@ -32,12 +32,7 @@ test('delete post with acl', async () => {
 			},
 		},
 		variables: {
-			locale_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['cs'] }],
-			},
+			locale_variable: { in: ['cs'] },
 		},
 		executes: [
 			...sqlTransaction([

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

@@ -34,12 +34,7 @@ test('set a name - allowed', async () => {
 			},
 		},
 		variables: {
-			name_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['John', 'Jack'] }],
-			},
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...sqlTransaction([
@@ -94,12 +89,7 @@ test('set a name - denied', async () => {
 			},
 		},
 		variables: {
-			name_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['John', 'Jack'] }],
-			},
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...failedTransaction([

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

@@ -27,12 +27,7 @@ test('insert author (with acl)', async () => {
 			},
 		},
 		variables: {
-			name_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['John', 'Jack'] }],
-			},
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		query: GQL`
         mutation {