@contember/engine-content-api 1.2.0-alpha.4 → 1.2.0-alpha.7

package/package.json

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

package/src/acl/EvaluatedPredicateReplacer.ts

@@ -0,0 +1,38 @@
+import { Input, Model, Writable } from '@contember/schema'
+import deepEqual from 'fast-deep-equal'
+
+export class EvaluatedPredicateReplacer {
+	constructor(
+		private readonly evaluatedPredicate: Input.Where,
+		private readonly sourceEntity: Model.Entity,
+		private readonly relation: Model.AnyRelation,
+	) {
+	}
+
+	public replace(where: Input.Where): Input.Where {
+		return this.replaceInternal(where, false)
+	}
+
+	private replaceInternal(where: Input.Where, onRelation: boolean): Input.Where {
+		if (onRelation && deepEqual(where, this.evaluatedPredicate)) {
+			return { [this.sourceEntity.primary]: { always: true } }
+		}
+		const result: Writable<Input.Where> = {}
+		for (const [key, value] of Object.entries(where)) {
+			if (key === 'not') {
+				result['not'] = this.replaceInternal(value as Input.Where, onRelation)
+
+			} else if (key === 'and' || key === 'or') {
+				result[key] = (value as Input.Where[]).map(it => this.replaceInternal(it, onRelation))
+
+			} else if (key === this.relation.name && !onRelation) {
+				result[key] = this.replaceInternal(value as Input.Where, true)
+
+			} else {
+				result[key] = value
+			}
+
+		}
+		return result
+	}
+}

package/src/acl/PredicateFactory.ts

@@ -1,10 +1,17 @@
 import { Acl, Input, Model } from '@contember/schema'
 import { VariableInjector } from './VariableInjector'
+import { isOwningRelation } from '@contember/schema-utils'
+import { ImplementationException } from '../exception'
+import { EvaluatedPredicateReplacer } from './EvaluatedPredicateReplacer'
 
 const getRowLevelPredicatePseudoField = (entity: Model.Entity) => entity.primary
 
 export class PredicateFactory {
-	constructor(private readonly permissions: Acl.Permissions, private readonly variableInjector: VariableInjector) {}
+	constructor(
+		private readonly permissions: Acl.Permissions,
+		private readonly model: Model.Schema,
+		private readonly variableInjector: VariableInjector,
+	) {}
 
 	public shouldApplyCellLevelPredicate(
 		entity: Model.Entity,
@@ -21,8 +28,9 @@ export class PredicateFactory {
 		entity: Model.Entity,
 		operation: Acl.Operation.update | Acl.Operation.read | Acl.Operation.create,
 		fieldNames?: string[],
+		overRelation?: Model.AnyRelation,
 	): Input.Where
-	public create(entity: Model.Entity, operation: Acl.Operation, fieldNames?: string[]): Input.Where {
+	public create(entity: Model.Entity, operation: Acl.Operation, fieldNames?: string[], overRelation?: Model.AnyRelation): Input.Where {
 		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name]
 		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
 
@@ -68,11 +76,8 @@ export class PredicateFactory {
 		if (predicatesWhere.length === 0) {
 			return {}
 		}
-		if (predicatesWhere.length === 1) {
-			return predicatesWhere[0]
-		}
-
-		return { and: predicatesWhere }
+		const where: Input.Where = predicatesWhere.length === 1 ? predicatesWhere[0] : { and: predicatesWhere }
+		return this.optimizePredicates(where, overRelation)
 	}
 
 	private getRequiredPredicates(
@@ -94,4 +99,22 @@ export class PredicateFactory {
 		}
 		return predicates
 	}
+
+	private optimizePredicates(where: Input.Where, overRelation?: Model.AnyRelation) {
+		if (!overRelation) {
+			return where
+		}
+		const otherSide = isOwningRelation(overRelation) ? overRelation.inversedBy : overRelation.ownedBy
+		if (!otherSide) {
+			throw new ImplementationException()
+		}
+		const sourceEntity = this.model.entities[overRelation.target]
+		const sourcePredicate = this.create(sourceEntity, Acl.Operation.read, [otherSide])
+		if (Object.keys(sourcePredicate).length === 0) {
+			return where
+		}
+
+		const replacer = new EvaluatedPredicateReplacer(sourcePredicate, sourceEntity, overRelation)
+		return replacer.replace(where)
+	}
 }

package/src/acl/PredicatesInjector.ts

@@ -5,17 +5,18 @@ import { PredicateFactory } from './PredicateFactory'
 export class PredicatesInjector {
 	constructor(private readonly schema: Model.Schema, private readonly predicateFactory: PredicateFactory) {}
 
-	public inject(entity: Model.Entity, where: Input.OptionalWhere): Input.OptionalWhere {
-		const restrictedWhere = this.injectToWhere(where, entity)
-		return this.createWhere(entity, undefined, restrictedWhere)
+	public inject(entity: Model.Entity, where: Input.OptionalWhere, overRelation?: Model.AnyRelation): Input.OptionalWhere {
+		const restrictedWhere = this.injectToWhere(where, entity, true)
+		return this.createWhere(entity, undefined, restrictedWhere, overRelation)
 	}
 
 	private createWhere(
 		entity: Model.Entity,
 		fieldNames: string[] | undefined,
 		where: Input.OptionalWhere,
+		overRelation?: Model.AnyRelation,
 	): Input.OptionalWhere {
-		const predicatesWhere: Input.Where = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames)
+		const predicatesWhere: Input.Where = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, overRelation)
 
 		const and = [where, predicatesWhere].filter(it => Object.keys(it).length > 0)
 		if (and.length === 0) {
@@ -27,18 +28,20 @@ export class PredicatesInjector {
 		return { and: and }
 	}
 
-	private injectToWhere(where: Input.OptionalWhere, entity: Model.Entity): Input.OptionalWhere {
+	private injectToWhere(where: Input.OptionalWhere, entity: Model.Entity, isRoot: boolean): 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))
+			resultWhere.and = where.and.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity, isRoot))
 		}
 		if (where.or) {
-			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity))
+			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity, isRoot))
 		}
 		if (where.not) {
-			resultWhere.not = this.injectToWhere(where.not, entity)
+			resultWhere.not = this.injectToWhere(where.not, entity, isRoot)
 		}
+
 		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
+
 		if (fields.length === 0) {
 			return resultWhere
 		}
@@ -48,11 +51,16 @@ export class PredicatesInjector {
 				visitRelation: (_a, _b, targetEntity) => targetEntity,
 			})
 			if (targetEntity) {
-				resultWhere[field] = this.injectToWhere(where[field] as Input.Where, targetEntity)
+				resultWhere[field] = this.injectToWhere(where[field] as Input.Where, targetEntity, false)
 			} else {
 				resultWhere[field] = where[field]
 			}
 		}
-		return this.createWhere(entity, fields, resultWhere)
+		const fieldsForPredicate = !isRoot
+			? fields
+			: fields.filter(it => this.predicateFactory.shouldApplyCellLevelPredicate(entity, Acl.Operation.read, it))
+
+		return this.createWhere(entity, fieldsForPredicate, resultWhere)
 	}
+
 }

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducerExecutionHandler.ts

@@ -31,7 +31,7 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 				}
 				const newObjectNode = objectNode.withArgs<Input.ListQueryInput>({ filter: whereWithParentId })
 
-				return context.mapper.select(targetEntity, newObjectNode, targetRelation.name)
+				return context.mapper.select(targetEntity, newObjectNode, targetRelation, targetRelation.name)
 			},
 			null,
 		)
@@ -40,7 +40,7 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 	private getRelationTarget(
 		entity: Model.Entity,
 		relationName: string,
-	): [Model.Entity, Model.Relation & Model.JoiningColumnRelation] {
+	): [Model.Entity, Model.AnyRelation & Model.JoiningColumnRelation] {
 		return acceptFieldVisitor(this.schema, entity, relationName, {
 			visitColumn: (): never => {
 				throw new ImplementationException('HasManyToHasOneReducerExecutionHandler: Not applicable for a column')
@@ -50,7 +50,7 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 				relation,
 				targetEntity,
 				targetRelation,
-			): [Model.Entity, Model.Relation & Model.JoiningColumnRelation] => {
+			): [Model.Entity, Model.AnyRelation & Model.JoiningColumnRelation] => {
 				if (!targetRelation || !isIt<Model.JoiningColumnRelation>(targetRelation, 'joiningColumn')) {
 					throw new Error('HasManyToHasOneReducerExecutionHandler: only applicable for relations with joiningColumn')
 				}

package/src/extensions/paginatedHasMany/PaginatedHasManyCountVisitor.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { GroupedCounts, JoiningColumns, Mapper, RelationFetcher } from '../../mapper'
+import { GroupedCounts, Mapper, RelationFetcher } from '../../mapper'
 import { ObjectNode } from '../../inputProcessing'
 
 export class PaginatedHasManyCountVisitor implements
@@ -20,11 +20,13 @@ export class PaginatedHasManyCountVisitor implements
 		targetRelation: Model.ManyHasOneRelation,
 	): Promise<GroupedCounts> {
 		return await this.relationFetcher.countOneHasManyGroups(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			targetRelation,
-			this.ids,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				targetEntity: targetEntity,
+				targetRelation: targetRelation,
+				ids: this.ids,
+			},
 		)
 	}
 
@@ -34,18 +36,16 @@ export class PaginatedHasManyCountVisitor implements
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyInverseRelation | null,
 	): Promise<GroupedCounts> {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
 		return await this.relationFetcher.countManyHasManyGroups(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			relation,
-			this.ids,
-			columns,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				targetEntity: targetEntity,
+				sourceRelation: relation,
+				targetRelation,
+				directionFrom: 'owning',
+				ids: this.ids,
+			},
 		)
 	}
 
@@ -55,18 +55,16 @@ export class PaginatedHasManyCountVisitor implements
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyOwningRelation,
 	): Promise<GroupedCounts> {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			targetColumn: joiningTable.joiningColumn,
-			sourceColumn: joiningTable.inverseJoiningColumn,
-		}
 		return await this.relationFetcher.countManyHasManyGroups(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			targetRelation,
-			this.ids,
-			columns,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				targetEntity: targetEntity,
+				sourceRelation: relation,
+				targetRelation,
+				directionFrom: 'inverse',
+				ids: this.ids,
+			},
 		)
 	}
 

package/src/extensions/paginatedHasMany/PaginatedHasManyNodesVisitor.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { GroupedCounts, JoiningColumns, Mapper, RelationFetcher, SelectGroupedObjects } from '../../mapper'
+import { Mapper, RelationFetcher, SelectGroupedObjects } from '../../mapper'
 import { ObjectNode } from '../../inputProcessing'
 
 export class PaginatedHasManyNodesVisitor implements
@@ -20,12 +20,14 @@ export class PaginatedHasManyNodesVisitor implements
 		targetRelation: Model.ManyHasOneRelation,
 	): Promise<SelectGroupedObjects> {
 		return await this.relationFetcher.fetchOneHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			targetRelation,
-			this.ids,
+			{
+				mapper: this.mapper,
+				objectNode: this.objectNode,
+				targetEntity: targetEntity,
+				relation: relation,
+				targetRelation: targetRelation,
+				ids: this.ids,
+			},
 		)
 	}
 
@@ -35,19 +37,16 @@ export class PaginatedHasManyNodesVisitor implements
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyInverseRelation | null,
 	): Promise<SelectGroupedObjects> {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
 		return await this.relationFetcher.fetchManyHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			relation,
-			columns,
-			this.ids,
+			{
+				mapper: this.mapper,
+				field: this.objectNode,
+				targetEntity: targetEntity,
+				sourceRelation: relation,
+				targetRelation,
+				directionFrom: 'owning',
+				ids: this.ids,
+			},
 		)
 	}
 
@@ -57,19 +56,16 @@ export class PaginatedHasManyNodesVisitor implements
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyOwningRelation,
 	): Promise<SelectGroupedObjects> {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			targetColumn: joiningTable.joiningColumn,
-			sourceColumn: joiningTable.inverseJoiningColumn,
-		}
 		return await this.relationFetcher.fetchManyHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			targetRelation,
-			columns,
-			this.ids,
+			{
+				mapper: this.mapper,
+				field: this.objectNode,
+				targetEntity: targetEntity,
+				sourceRelation: relation,
+				targetRelation,
+				directionFrom: 'inverse',
+				ids: this.ids,
+			},
 		)
 	}
 

package/src/input-validation/ValidationDataSelector.ts

@@ -1,6 +1,6 @@
 import { QueryAstFactory } from './QueryAstFactory'
 import { Mapper } from '../mapper'
-import { Dependencies, DependencyCollector } from './dependencies'
+import { Dependencies } from './dependencies'
 import { Input, Model, Value } from '@contember/schema'
 
 export class ValidationDataSelector {
@@ -20,7 +20,7 @@ export class ValidationDataSelector {
 			return {}
 		}
 		const queryAst = this.queryAstFactory.create(entity.name, dependencies).withArg('by', where)
-		const node = await mapper.selectUnique(entity, queryAst)
+		const node = await mapper.selectUnique(entity, queryAst, null)
 		if (!node) {
 			return null
 		}

package/src/mapper/Mapper.ts

@@ -56,15 +56,17 @@ export class Mapper {
 		return result[0] !== undefined ? result[0][columnName] : undefined
 	}
 
-	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>): Promise<SelectResultObject[]>
+	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>, overRelation: Model.AnyRelation | null): Promise<SelectResultObject[]>
 	public async select(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
+		overRelation: Model.AnyRelation | null,
 		indexBy: string,
 	): Promise<SelectIndexedResultObjects>
 	public async select(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
+		overRelation: Model.AnyRelation | null,
 		indexBy?: string,
 	): Promise<SelectResultObject[] | SelectIndexedResultObjects> {
 		const hydrator = new SelectHydrator()
@@ -75,7 +77,7 @@ export class Mapper {
 			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)
+		const rows = await this.selectRows(hydrator, qb, entity, input, overRelation)
 
 		return await (indexByAlias !== null ? hydrator.hydrateAll(rows, indexByAlias) : hydrator.hydrateAll(rows))
 	}
@@ -83,18 +85,19 @@ export class Mapper {
 	public async selectUnique(
 		entity: Model.Entity,
 		query: ObjectNode<Input.UniqueQueryInput>,
+		overRelation: Model.AnyRelation | null,
 	): Promise<SelectResultObject | null> {
 		const uniqueWhere = this.uniqueWhereExpander.expand(entity, query.args.by)
 		const where = query.args.filter ? { and: [uniqueWhere, query.args.filter] } : uniqueWhere
 		const queryExpanded = query.withArg<Input.ListQueryInput>('filter', where)
 
-		return (await this.select(entity, queryExpanded))[0] || null
+		return (await this.select(entity, queryExpanded, overRelation))[0] || null
 	}
 
 	public async selectGrouped(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
-		relation: Model.JoiningColumnRelation & Model.Relation,
+		relation: Model.JoiningColumnRelation & Model.AnyRelation,
 	) {
 		const hydrator = new SelectHydrator()
 		let qb: SelectBuilder<SelectBuilder.Result> = SelectBuilder.create()
@@ -102,7 +105,7 @@ export class Mapper {
 		const groupingKey = '__grouping_key'
 		qb = qb.select([path.alias, relation.joiningColumn.columnName], groupingKey)
 
-		const rows = await this.selectRows(hydrator, qb, entity, input, relation.name)
+		const rows = await this.selectRows(hydrator, qb, entity, input, relation, relation.name)
 		return await hydrator.hydrateGroups(rows, groupingKey)
 	}
 
@@ -111,6 +114,7 @@ export class Mapper {
 		qb: SelectBuilder<SelectBuilder.Result>,
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
+		overRelation: Model.AnyRelation | null,
 		groupBy?: string,
 	) {
 		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, [])
@@ -118,7 +122,7 @@ export class Mapper {
 		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 filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {}, overRelation ?? undefined)
 		const inputWithPredicates = inputWithOrder.withArg('filter', filterWithPredicates)
 		selector.select(this, entity, inputWithPredicates, path, groupBy)
 		return await selector.execute(this.db)

package/src/mapper/MapperContainer.ts

@@ -32,6 +32,8 @@ import { Client, SelectBuilder as DbSelectBuilder } from '@contember/database'
 import { Providers } from '@contember/schema-utils'
 import { PaginatedHasManyExecutionHandler } from '../extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
 import { PaginatedHasManyFieldProvider } from '../extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
+import { WhereOptimizer } from './select/optimizer/WhereOptimizer'
+import { ConditionOptimizer } from './select/optimizer/ConditionOptimizer'
 
 type MapperContainerArgs = {
 	schema: Schema
@@ -51,7 +53,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 		.addService('variableInjector', () =>
 			new VariableInjector(schema.model, identityVariables))
 		.addService('predicateFactory', ({ variableInjector }) =>
-			new PredicateFactory(permissions, variableInjector))
+			new PredicateFactory(permissions, schema.model, variableInjector))
 		.addService('predicatesInjector', ({ predicateFactory }) =>
 			new PredicatesInjector(schema.model, predicateFactory))
 		.addService('joinBuilder', () =>
@@ -60,8 +62,10 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 			new ConditionBuilder())
 		.addService('pathFactory', () =>
 			new PathFactory())
-		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory }) =>
-			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory))
+		.addService('whereOptimized', () =>
+			new WhereOptimizer(schema.model, new ConditionOptimizer()))
+		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized }) =>
+			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized))
 		.addService('orderByBuilder', ({ joinBuilder }) =>
 			new OrderByBuilder(schema.model, joinBuilder))
 		.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>