@contember/engine-content-api 2.1.0-alpha.30 → 2.1.0-alpha.36

package/src/acl/PredicatesInjector.ts

@@ -5,9 +5,32 @@ 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, relationContext?: Model.AnyRelationContext): Input.OptionalWhere {
-		const restrictedWhere = this.injectToWhere(where, entity, true)
-		return this.createWhere(entity, undefined, restrictedWhere, relationContext)
+	public inject(
+		entity: Model.Entity,
+		where: Input.OptionalWhere,
+		relationContext?: Model.AnyRelationContext,
+		ancestorPath?: readonly Model.AnyRelationContext[],
+	): Input.OptionalWhere {
+		const restrictedWhere = this.injectToWhere(where, entity, true, relationContext, false, ancestorPath ?? [])
+		return this.createWhere(entity, undefined, restrictedWhere, relationContext, false, ancestorPath ?? [])
+	}
+
+	/**
+	 * Finds an ancestor in the path that matches the given relation as a back-reference.
+	 * A match occurs when:
+	 * 1. The relation we're traversing has the same name as the inverse (targetRelation) of a relation in the ancestor path
+	 * 2. AND the entity where our relation is defined matches the targetEntity in the path
+	 *    (to prevent false positives when different entities have relations with the same name)
+	 */
+	private findBackReferencedAncestor(
+		ancestorPath: readonly Model.AnyRelationContext[],
+		relationName: string,
+		relationSourceEntityName: string,
+	): Model.AnyRelationContext | undefined {
+		return ancestorPath.find(ctx =>
+			ctx.targetRelation?.name === relationName
+			&& ctx.targetEntity.name === relationSourceEntityName
+		)
 	}
 
 	private createWhere(
@@ -15,9 +38,32 @@ export class PredicatesInjector {
 		fieldNames: string[] | undefined,
 		where: Input.OptionalWhere,
 		relationContext?: Model.AnyRelationContext,
+		isBackReferenceContext?: boolean,
+		ancestorPath?: readonly Model.AnyRelationContext[],
 	): Input.OptionalWhere {
-		const predicatesWhere = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext)
-		where = this.predicateFactory.optimizePredicates(where, relationContext)
+		// Simplify predicates when:
+		// 1. We're in a back-reference context (inside a filter that traverses back)
+		// 2. AND the relation we traversed to get here corresponds to a relation in our query path
+		// This ensures we only simplify when the traversed relation actually corresponds
+		// to a relation in our query path (not just any relation to the same entity type)
+		const shouldSimplify = isBackReferenceContext === true
+			&& ancestorPath !== undefined
+			&& relationContext !== undefined
+			&& this.findBackReferencedAncestor(ancestorPath, relationContext.relation.name, relationContext.entity.name) !== undefined
+
+		let predicatesWhere: Input.OptionalWhere
+		if (shouldSimplify) {
+			predicatesWhere = { [entity.primary]: { always: true } }
+		} else {
+			const rawPredicate = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext)
+			// Process the predicate to inject nested entity predicates
+			predicatesWhere = this.injectPredicatesToPredicate(
+				rawPredicate,
+				entity,
+				isBackReferenceContext ?? false,
+				ancestorPath ?? [],
+			)
+		}
 
 		const and = [where, predicatesWhere].filter(it => Object.keys(it).length > 0)
 		if (and.length === 0) {
@@ -29,21 +75,120 @@ export class PredicatesInjector {
 		return { and: and }
 	}
 
+	/**
+	 * Processes a predicate and injects nested entity predicates for any relation traversals.
+	 * This ensures that when a predicate like { department: { company: { name: 'Acme' } } }
+	 * is used, the predicates of Department and Company are also applied.
+	 */
+	private injectPredicatesToPredicate(
+		where: Input.OptionalWhere,
+		entity: Model.Entity,
+		isBackReferenceContext: boolean,
+		ancestorPath: readonly Model.AnyRelationContext[],
+	): Input.OptionalWhere {
+		const resultWhere: Writable<Input.OptionalWhere> = {}
+
+		if (where.and) {
+			resultWhere.and = where.and
+				.filter((it): it is Input.Where => !!it)
+				.map(it => this.injectPredicatesToPredicate(it, entity, isBackReferenceContext, ancestorPath))
+		}
+		if (where.or) {
+			resultWhere.or = where.or
+				.filter((it): it is Input.Where => !!it)
+				.map(it => this.injectPredicatesToPredicate(it, entity, isBackReferenceContext, ancestorPath))
+		}
+		if (where.not) {
+			resultWhere.not = this.injectPredicatesToPredicate(where.not, entity, isBackReferenceContext, ancestorPath)
+		}
+
+		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
+
+		for (const field of fields) {
+			resultWhere[field] = acceptFieldVisitor(this.schema, entity, field, {
+				visitColumn: () => where[field],
+				visitRelation: context => {
+					const relationWhere = where[field] as Input.OptionalWhere | null
+					if (relationWhere === null) {
+						return null
+					}
+
+					// Check if this relation is a back-reference to somewhere in our ancestor path
+					const isBackReference = this.findBackReferencedAncestor(
+						ancestorPath,
+						context.relation.name,
+						context.entity.name,
+					) !== undefined
+					const nestedIsBackReferenceContext = isBackReference || isBackReferenceContext
+					const nestedAncestorPath: readonly Model.AnyRelationContext[] = [...ancestorPath, context]
+
+					// Recursively process the nested where (always do this to handle deeper nesting)
+					const processedNestedWhere = this.injectPredicatesToPredicate(
+						relationWhere,
+						context.targetEntity,
+						nestedIsBackReferenceContext,
+						nestedAncestorPath,
+					)
+
+					// Check if we should simplify the target entity's predicate
+					const shouldSimplifyNested = nestedIsBackReferenceContext
+						&& this.findBackReferencedAncestor(nestedAncestorPath, context.relation.name, context.entity.name) !== undefined
+
+					// Get target entity's predicate (simplified if back-reference)
+					const targetPredicate = shouldSimplifyNested
+						? { [context.targetEntity.primary]: { always: true } }
+						: this.predicateFactory.create(context.targetEntity, Acl.Operation.read, undefined, context)
+
+					// Optimization: avoid duplicate { id: always } when both are simplified
+					const primaryKey = context.targetEntity.primary
+					const nestedIsAlwaysTrue = Object.keys(processedNestedWhere).length === 1
+						&& (processedNestedWhere as Record<string, unknown>)[primaryKey] !== undefined
+						&& (processedNestedWhere as Record<string, Record<string, unknown>>)[primaryKey]?.always === true
+					const targetIsAlwaysTrue = Object.keys(targetPredicate).length === 1
+						&& (targetPredicate as Record<string, unknown>)[primaryKey] !== undefined
+						&& (targetPredicate as Record<string, Record<string, unknown>>)[primaryKey]?.always === true
+
+					if (nestedIsAlwaysTrue && targetIsAlwaysTrue) {
+						return processedNestedWhere
+					}
+
+					// Combine the processed nested where with target entity's predicate
+					const parts = [processedNestedWhere, targetPredicate].filter(it => Object.keys(it).length > 0)
+					if (parts.length === 0) {
+						return {}
+					}
+					if (parts.length === 1) {
+						return parts[0]
+					}
+					return { and: parts }
+				},
+			})
+		}
+
+		return resultWhere
+	}
+
 	private injectToWhere(
 		where: Input.OptionalWhere,
 		entity: Model.Entity,
 		isRoot: boolean,
-		relationContext?: Model.AnyRelationContext,
+		relationContext: Model.AnyRelationContext | undefined,
+		isBackReferenceContext: boolean,
+		ancestorPath: readonly Model.AnyRelationContext[],
 	): 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, isRoot, relationContext))
+			resultWhere.and = where.and.filter((it): it is Input.Where => !!it).map(it =>
+				this.injectToWhere(it, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath)
+			)
 		}
 		if (where.or) {
-			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity, isRoot, relationContext))
+			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it =>
+				this.injectToWhere(it, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath)
+			)
 		}
 		if (where.not) {
-			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext)
+			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath)
 		}
 
 		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
@@ -59,7 +204,13 @@ export class PredicatesInjector {
 					if (relationWhere === null) {
 						return null
 					}
-					return this.injectToWhere(relationWhere, context.targetEntity, false, context)
+					// Check if this relation is a back-reference to somewhere in our ancestor path
+					const isBackReference = this.findBackReferencedAncestor(ancestorPath, context.relation.name, context.entity.name) !== undefined
+					// Once we enter a back-reference context, stay in it for nested relations
+					const nestedIsBackReferenceContext = isBackReference || isBackReferenceContext
+					// Build extended ancestor path for nested traversal
+					const nestedAncestorPath: Model.AnyRelationContext[] = [...ancestorPath, context]
+					return this.injectToWhere(relationWhere, context.targetEntity, false, context, nestedIsBackReferenceContext, nestedAncestorPath)
 				},
 			})
 		}
@@ -67,7 +218,6 @@ export class PredicatesInjector {
 			? fields
 			: fields.filter(it => this.predicateFactory.shouldApplyCellLevelPredicate(entity, Acl.Operation.read, it))
 
-		return this.createWhere(entity, fieldsForPredicate, resultWhere, relationContext)
+		return this.createWhere(entity, fieldsForPredicate, resultWhere, relationContext, isBackReferenceContext, ancestorPath)
 	}
-
 }

package/src/acl/VariableUtils.ts

@@ -1,12 +1,10 @@
 import { Acl, Input } from '@contember/schema'
 import { getRoleVariables, ParsedMembership } from '@contember/schema-utils'
 
-
 export const createAclVariables = (
 	aclSchema: Acl.Schema,
 	memberships: readonly ParsedMembership[],
 ): Acl.VariablesMap => {
-
 	const variablesEntries = memberships.flatMap(
 		membership => {
 			const roleVariables = getRoleVariables(membership.role, aclSchema)

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducerExecutionHandler.ts

@@ -7,7 +7,6 @@ import { UniqueWhereExpander } from '../../inputProcessing'
 import { HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer'
 
 export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHandler<Input.UniqueQueryInput, HasManyToHasOneReducerExtension> {
-
 	constructor(private readonly schema: Model.Schema, private readonly uniqueWhereExpander: UniqueWhereExpander) {}
 
 	process(context: SelectExecutionHandlerContext<Input.UniqueQueryInput, HasManyToHasOneReducerExtension>): void {
@@ -18,7 +17,6 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 		addData({
 			field: entity.primary,
 			dataProvider: async (ids: Input.PrimaryValue[]) => {
-
 				const relationContext = acceptFieldVisitor(this.schema, entity, objectNode.extensions.relationName, {
 					visitRelation: context => context,
 					visitColumn: (): never => {

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneRelationReducerVisitor.ts

@@ -11,13 +11,10 @@ type Result = [
 	string,
 	GraphQLFieldConfig<any, any> & {
 		extensions: HasManyToHasOneReducerExtension
-	}
+	},
 ]
 
-export class HasManyToHasOneRelationReducerFieldVisitor implements
-	Model.ColumnVisitor<Result[]>,
-	Model.RelationByTypeVisitor<Result[]> {
-
+export class HasManyToHasOneRelationReducerFieldVisitor implements Model.ColumnVisitor<Result[]>, Model.RelationByTypeVisitor<Result[]> {
 	constructor(
 		private readonly schema: Model.Schema,
 		private readonly authorizator: Authorizator,
@@ -58,10 +55,10 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 		const uniqueKeys: (readonly string[])[] = uniqueConstraints
 			.map(it => it.filter(it => it !== targetRelation.name))
 			.filter(it => it.length > 0)
-			.filter(uniqueKey => uniqueKey
-				.every(it =>
-					acceptFieldVisitor(this.schema, targetEntity.name, it, new FieldAccessVisitor(Acl.Operation.read, this.authorizator)),
-				))
+			.filter(uniqueKey =>
+				uniqueKey
+					.every(it => acceptFieldVisitor(this.schema, targetEntity.name, it, new FieldAccessVisitor(Acl.Operation.read, this.authorizator)))
+			)
 
 		const graphQlName = relation.name + 'By'
 		const uniqueWhere: GraphQLInputObjectType = new GraphQLInputObjectType({
@@ -89,7 +86,7 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 		]
 
 		const composedUnique = uniqueConstraints
-			.filter(fields => fields.length === 2) //todo support all uniques
+			.filter(fields => fields.length === 2) // todo support all uniques
 			.filter(fields => fields.includes(targetRelation.name))
 			.map(fields => fields.filter(it => it !== targetRelation.name))
 			.map(fields => fields[0])
@@ -98,7 +95,6 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 			.map(fields => fields[0])
 			.filter(it => it !== targetRelation.name)
 
-
 		const existing = new Set<string>()
 		return [...composedUnique, ...singleUnique]
 			.filter(field =>
@@ -107,7 +103,7 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 					targetEntity.name,
 					field,
 					new FieldAccessVisitor(Acl.Operation.read, this.authorizator),
-				),
+				)
 			)
 			.map<Result | null>(fieldName => {
 				if (existing.has(fieldName)) {
@@ -116,7 +112,7 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 				existing.add(fieldName)
 				const graphQlName = relation.name + GqlTypeName`By${fieldName}`
 				const uniqueWhere: GraphQLInputObjectType = new GraphQLInputObjectType({
-					//todo this can be simplified to ${targetEntity.name}By${fieldName}, but singleton must be used
+					// todo this can be simplified to ${targetEntity.name}By${fieldName}, but singleton must be used
 					name: GqlTypeName`${entity.name}${relation.name}By${fieldName}UniqueWhere`,
 					fields: () => {
 						return this.whereTypeProvider.getUniqueWhereFields(targetEntity, [[fieldName]])

package/src/extensions/paginatedHasMany/PaginatedHasManyCountVisitor.ts

@@ -2,10 +2,9 @@ import { Input, Model } from '@contember/schema'
 import { GroupedCounts, Mapper, RelationFetcher } from '../../mapper'
 import { ObjectNode } from '../../inputProcessing'
 
-export class PaginatedHasManyCountVisitor implements
-	Model.ColumnVisitor<Promise<GroupedCounts>>,
-	Model.RelationByTypeVisitor<Promise<GroupedCounts>> {
-
+export class PaginatedHasManyCountVisitor
+	implements Model.ColumnVisitor<Promise<GroupedCounts>>, Model.RelationByTypeVisitor<Promise<GroupedCounts>>
+{
 	constructor(
 		private readonly ids: Input.PrimaryValue[],
 		private readonly objectNode: ObjectNode<Input.PaginationQueryInput>,

package/src/extensions/paginatedHasMany/PaginatedHasManyExecutionHandler.ts

@@ -29,7 +29,7 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 						entity,
 						objectNode.extensions.relationName,
 						new PaginatedHasManyCountVisitor(ids, objectNode, this.relationFetcher, mapper, context.relationPath),
-					  )
+					)
 					: {}
 
 				const nodes = pagination.nodeField
@@ -38,7 +38,7 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 						entity,
 						objectNode.extensions.relationName,
 						new PaginatedHasManyNodesVisitor(ids, pagination.nodeField, this.relationFetcher, mapper, context.relationPath),
-					  )
+					)
 					: undefined
 				const result = new Map<Input.PrimaryValue, any>()
 				for (const id of ids) {

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor.ts

@@ -9,13 +9,10 @@ type Result = [
 	string,
 	GraphQLFieldConfig<any, any> & {
 		extensions: PaginatedHasManyFieldProviderExtension
-	}
+	},
 ]
 
-export class PaginatedHasManyFieldProviderVisitor implements
-	Model.ColumnVisitor<Result[]>,
-	Model.RelationByTypeVisitor<Result[]> {
-
+export class PaginatedHasManyFieldProviderVisitor implements Model.ColumnVisitor<Result[]>, Model.RelationByTypeVisitor<Result[]> {
 	constructor(private readonly paginatedFieldFactory: PaginatedFieldConfigFactory) {}
 
 	visitOneHasMany({ targetEntity, relation }: Model.OneHasManyContext) {

package/src/extensions/paginatedHasMany/PaginatedHasManyNodesVisitor.ts

@@ -2,10 +2,9 @@ import { Input, Model } from '@contember/schema'
 import { Mapper, RelationFetcher, SelectGroupedObjects } from '../../mapper'
 import { ObjectNode } from '../../inputProcessing'
 
-export class PaginatedHasManyNodesVisitor implements
-	Model.ColumnVisitor<Promise<SelectGroupedObjects>>,
-	Model.RelationByTypeVisitor<Promise<SelectGroupedObjects>> {
-
+export class PaginatedHasManyNodesVisitor
+	implements Model.ColumnVisitor<Promise<SelectGroupedObjects>>, Model.RelationByTypeVisitor<Promise<SelectGroupedObjects>>
+{
 	constructor(
 		private readonly ids: Input.PrimaryValue[],
 		private readonly objectNode: ObjectNode<Input.PaginationQueryInput>,

package/src/index.ts

@@ -9,7 +9,6 @@ export * from './ExecutionContainer'
 export { graphql } from 'graphql'
 export { UserError } from './exception'
 export {
-	type DataModificationEvent,
 	AfterCommitEvent,
 	AfterInsertEvent,
 	AfterJunctionUpdateEvent,
@@ -19,17 +18,18 @@ export {
 	BeforeInsertEvent,
 	BeforeJunctionUpdateEvent,
 	BeforeUpdateEvent,
+	type DataModificationEvent,
 	EventManager,
-	Mapper,
-	MapperFactory,
 	type ExecutionContainer,
+	type ExecutionContainerArgs,
 	type ExecutionContainerBuilder,
-	Path,
-	type WhereBuilder,
-	type JoinBuilder,
-	PathFactory,
 	ExecutionContainerFactory,
 	type ExecutionContainerHook,
-	type ExecutionContainerArgs,
+	type JoinBuilder,
+	Mapper,
+	MapperFactory,
+	Path,
+	PathFactory,
+	type WhereBuilder,
 } from './mapper'
 export * from './utils/uniqueWhereFields'

package/src/input-validation/ValidationEvaluation.ts

@@ -83,8 +83,7 @@ const validatorEvaluators: {
 		return acceptContextVisitor(context, {
 			visitNodeContext: fixedResult(false),
 			visitNodeListContext: (context: ValidationContext.NodeListContext) => context.nodes.length === 0,
-			visitValueContext: (context: ValidationContext.ValueContext) =>
-				context.value === undefined || context.value === null || context.value === '',
+			visitValueContext: (context: ValidationContext.ValueContext) => context.value === undefined || context.value === null || context.value === '',
 			visitUndefinedContext: fixedResult(true),
 		})
 	},
@@ -92,8 +91,7 @@ const validatorEvaluators: {
 		return acceptContextVisitor(context, {
 			visitNodeContext: fixedResult(true),
 			visitNodeListContext: fixedResult(true),
-			visitValueContext: (context: ValidationContext.ValueContext) =>
-				context.value !== undefined && context.value !== null,
+			visitValueContext: (context: ValidationContext.ValueContext) => context.value !== undefined && context.value !== null,
 			visitUndefinedContext: fixedResult(false),
 		})
 	},
@@ -135,8 +133,7 @@ const validatorEvaluators: {
 		min: Validation.LiteralArgument<number | null>,
 		max: Validation.LiteralArgument<number | null>,
 	) => {
-		const doesMatchRange = (value: number) =>
-			(min.value === null || min.value <= value) && (max.value === null || max.value >= value)
+		const doesMatchRange = (value: number) => (min.value === null || min.value <= value) && (max.value === null || max.value >= value)
 		return acceptContextVisitor(context, {
 			visitNodeContext: cannotApplyOnNode('length range', 'node'),
 			visitNodeListContext: (context: ValidationContext.NodeListContext) => {

package/src/input-validation/dependencies/DependencyCollector.ts

@@ -32,9 +32,9 @@ export class DependencyCollector {
 		const result: DependenciesList = []
 		for (const arg of validator.args) {
 			switch (arg.type) {
-				//case Validation.ArgumentType.path:
-				//	result.push([...prefix, ...arg.path])
-				//	break
+				// case Validation.ArgumentType.path:
+				// 	result.push([...prefix, ...arg.path])
+				// 	break
 				case Validation.ArgumentType.validator:
 					result.push(...DependencyCollector.doCollect(arg.validator, prefix))
 					break

package/src/input-validation/preValidation/InputPreValidator.ts

@@ -48,7 +48,7 @@ export class InputPreValidator {
 			? {
 				...data,
 				[overRelation.name]: { create: {} },
-			  }
+			}
 			: data
 		const context = this.createContextForCreate(entity, dataWithRelation)
 
@@ -114,8 +114,8 @@ export class InputPreValidator {
 				}
 				if ('delete' in value) {
 					if (
-						isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn') &&
-						relation.joiningColumn.onDelete === Model.OnDelete.cascade
+						isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn')
+						&& relation.joiningColumn.onDelete === Model.OnDelete.cascade
 					) {
 						return true
 					}
@@ -150,7 +150,7 @@ export class InputPreValidator {
 				tuple(
 					field,
 					fieldRules.find(it => evaluateValidation(context, InputValidation.rules.on(field, it.validator)) === false),
-				),
+				)
 			)
 			.filter((arg): arg is [string, Validation.ValidationRule] => !!arg[1])
 			.map(([field, { message }]) => ({ path: [...path, { field }], message }))
@@ -174,9 +174,7 @@ export class InputPreValidator {
 						field,
 						changedFields.includes(field)
 							? fieldRules
-							: fieldRules.filter(rule =>
-								Object.keys(DependencyCollector.collect(rule.validator)).find(it => changedFields.includes(it)),
-							  ),
+							: fieldRules.filter(rule => Object.keys(DependencyCollector.collect(rule.validator)).find(it => changedFields.includes(it))),
 					)
 				})
 				.filter(([, it]) => it.length > 0),
@@ -187,7 +185,7 @@ export class InputPreValidator {
 		const baseFieldsAsDeps = Object.keys(rules).reduce((acc, field) => ({ ...acc, [field]: {} }), {})
 
 		return Object.values(rules)
-			.flatMap(it => it)
+			.flat()
 			.map(it => DependencyCollector.collect(it.validator))
 			.concat(baseFieldsAsDeps)
 			.reduce((acc, dependecy) => DependencyMerger.merge(acc, dependecy), {})

package/src/inputProcessing/CreateInputProcessor.ts

@@ -16,7 +16,6 @@ interface CreateInputProcessor<Result = void> {
 }
 
 namespace CreateInputProcessor {
-
 	export interface HasOneRelationProcessor<Context, Result> {
 		nothing?: (context: Context & { input: undefined }) => Promise<Result>
 		connect: (context: Context & { input: Input.UniqueWhere | CheckedPrimary }) => Promise<Result>
@@ -31,4 +30,4 @@ namespace CreateInputProcessor {
 	}
 }
 
-export { type CreateInputProcessor }
+export type { CreateInputProcessor }

package/src/inputProcessing/CreateInputVisitor.ts

@@ -4,10 +4,7 @@ import { CreateInputProcessor } from './CreateInputProcessor'
 import { ImplementationException, UserError } from '../exception'
 import { MapperInput } from '../mapper'
 
-export class CreateInputVisitor<Result> implements
-	Model.ColumnVisitor<Promise<Result[]>>,
-	Model.RelationByTypeVisitor<Promise<Result[]>> {
-
+export class CreateInputVisitor<Result> implements Model.ColumnVisitor<Promise<Result[]>>, Model.RelationByTypeVisitor<Promise<Result[]>> {
 	constructor(
 		private readonly createInputProcessor: CreateInputProcessor<Result>,
 		private readonly schema: Model.Schema,
@@ -15,10 +12,12 @@ export class CreateInputVisitor<Result> implements
 	) {}
 
 	public async visitColumn(context: Model.ColumnContext): Promise<Result[]> {
-		return [await this.createInputProcessor.column({
-			...context,
-			input: this.data[context.column.name] as Input.ColumnValue,
-		})]
+		return [
+			await this.createInputProcessor.column({
+				...context,
+				input: this.data[context.column.name] as Input.ColumnValue,
+			}),
+		]
 	}
 
 	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {

package/src/inputProcessing/UpdateInputProcessor.ts

@@ -2,7 +2,6 @@ import { Input, Model } from '@contember/schema'
 import { CheckedPrimary } from '../mapper/CheckedPrimary'
 import { MapperInput } from '../mapper'
 
-
 interface UpdateInputProcessor<Result = void> {
 	column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<Result>
 
@@ -61,4 +60,4 @@ namespace UpdateInputProcessor {
 	}
 }
 
-export { type UpdateInputProcessor }
+export type { UpdateInputProcessor }

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -4,10 +4,7 @@ import { UpdateInputProcessor } from './UpdateInputProcessor'
 import { ImplementationException, UserError } from '../exception'
 import { MapperInput } from '../mapper'
 
-export class UpdateInputVisitor<Result> implements
-	Model.ColumnVisitor<Promise<Result[]>>,
-	Model.RelationByTypeVisitor<Promise<Result[]>> {
-
+export class UpdateInputVisitor<Result> implements Model.ColumnVisitor<Promise<Result[]>>, Model.RelationByTypeVisitor<Promise<Result[]>> {
 	constructor(
 		private readonly updateInputProcessor: UpdateInputProcessor<Result>,
 		private readonly schema: Model.Schema,
@@ -15,11 +12,13 @@ export class UpdateInputVisitor<Result> implements
 	) {}
 
 	public async visitColumn({ entity, column }: Model.ColumnContext): Promise<Result[]> {
-		return [await this.updateInputProcessor.column({
-			entity,
-			column,
-			input: this.data[column.name] as Input.ColumnValue,
-		})]
+		return [
+			await this.updateInputProcessor.column({
+				entity,
+				column,
+				input: this.data[column.name] as Input.ColumnValue,
+			}),
+		]
 	}
 
 	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
@@ -74,7 +73,7 @@ export class UpdateInputVisitor<Result> implements
 		processor: UpdateInputProcessor.HasOneRelationInputProcessor<Context, Result>,
 		context: Context,
 		input: MapperInput.UpdateOneRelationInput | undefined,
-	): Promise< Result[]> {
+	): Promise<Result[]> {
 		if (input === undefined || input === null) {
 			return Promise.resolve([])
 		}

package/src/introspection/IntrospectionSchemaFactory.ts

@@ -33,10 +33,9 @@ export class IntrospectionSchemaFactory {
 		const convertOrderBy = ({ path, direction }: Model.OrderBy): ContentSchema._OrderBy => {
 			return {
 				path,
-				direction:
-					direction === Model.OrderDirection.desc
-						? ContentSchema._OrderByDirection.Desc
-						: ContentSchema._OrderByDirection.Asc,
+				direction: direction === Model.OrderDirection.desc
+					? ContentSchema._OrderByDirection.Desc
+					: ContentSchema._OrderByDirection.Asc,
 			}
 		}
 		const additionalInfo = acceptEveryFieldVisitor<AdditionalFieldInfo>(this.model, entityName, {

package/src/introspection/content-schema.types.ts

@@ -61,7 +61,7 @@ export type _LiteralArgument = {
 export enum _OnDeleteBehaviour {
 	Cascade = 'cascade',
 	Restrict = 'restrict',
-	SetNull = 'setNull'
+	SetNull = 'setNull',
 }
 
 export type _OrderBy = {
@@ -72,7 +72,7 @@ export type _OrderBy = {
 
 export enum _OrderByDirection {
 	Asc = 'asc',
-	Desc = 'desc'
+	Desc = 'desc',
 }
 
 export type _PathArgument = {
@@ -98,7 +98,7 @@ export type _Relation = _Field & {
 
 export enum _RelationSide {
 	Inverse = 'inverse',
-	Owning = 'owning'
+	Owning = 'owning',
 }
 
 export type _Rule = {

package/src/introspection/introspection.schema.ts

@@ -174,7 +174,6 @@ const _Schema = new GraphQLObjectType({
 	},
 })
 
-
 export const createSchemaConfig = (resolver?: GraphQLFieldResolver<any, any>): GraphQLSchemaConfig => {
 	return {
 		query: new GraphQLObjectType({
@@ -190,5 +189,4 @@ export const createSchemaConfig = (resolver?: GraphQLFieldResolver<any, any>): G
 	}
 }
 
-
 export default new GraphQLSchema(createSchemaConfig())