@contember/engine-content-api 2.1.0-alpha.9 → 2.1.0-beta.2

package/src/mapper/update/Updater.ts

@@ -1,21 +1,24 @@
 import { SqlUpdateInputProcessor, SqlUpdateInputProcessorResult } from './SqlUpdateInputProcessor'
 import { UpdateInputVisitor } from '../../inputProcessing'
 import { Input, Model } from '@contember/schema'
-import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason } from '../Result'
+import {
+	MutationEntryNotFoundError,
+	MutationNoResultError,
+	MutationNothingToDo,
+	MutationResultList,
+	MutationUpdateOk,
+	NothingToDoReason,
+} from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
-import { DatabaseMetadata } from '@contember/database'
 import { MapperInput } from '../types'
 
 export class Updater {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: DatabaseMetadata,
-		private readonly predicateFactory: PredicateFactory,
 		private readonly updateBuilderFactory: UpdateBuilderFactory,
 	) {}
 
@@ -66,6 +69,21 @@ export class Updater {
 		const result = await updateBuilder.execute(mapper)
 
 		if (!result.executed) {
+			if (filter && Object.keys(filter).length > 0) {
+				// direct update was not invoked, but we still need to check if the row matches the filter
+				const where: Input.OptionalWhere = {
+					and: [
+						filter,
+						{
+							[entity.primary]: { eq: primaryValue },
+						},
+					],
+				}
+				const count = await mapper.count(entity, where)
+				if (!count) {
+					return [new MutationEntryNotFoundError([], where)]
+				}
+			}
 			resultList.unshift(new MutationNothingToDo([], NothingToDoReason.noData))
 		} else if (result.affectedRows !== 1) {
 			return [new MutationNoResultError([])]

package/src/mapper/update/relations/ManyHasOneUpdateInputProcessor.ts

@@ -16,8 +16,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.ManyHasOneContext
 
-export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
-
+export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 		private readonly builder: UpdateBuilder,
@@ -93,8 +92,7 @@ export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasO
 			return insertResult
 		}
 
-		return async () =>
-			await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), update)
+		return async () => await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), update)
 	}
 
 	public async disconnect(

package/src/mapper/update/relations/OneHasManyUpdateInputProcessor.ts

@@ -8,7 +8,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasManyContext
 
-export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 	) {
@@ -75,7 +75,7 @@ export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasM
 				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
 				{
 					...update,
-				// [targetRelation.name]: {connect: thisPrimary}
+					// [targetRelation.name]: {connect: thisPrimary}
 				},
 			)
 			if (result[0].result === MutationResultType.notFoundError) {

package/src/mapper/update/relations/OneHasOneInverseUpdateInputProcessor.ts

@@ -15,14 +15,16 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneInverseContext
 
-export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasOneInverseUpdateInputProcessor
+	implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>
+{
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
 		private readonly mapper: Mapper,
 	) {
 	}
 
-	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere | CheckedPrimary }) {
+	public async connect({ input, ...ctx }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere | CheckedPrimary }) {
 		return async () => {
 			const [newOwner, err] = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
 			if (err) return [err]
@@ -42,7 +44,6 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		}
 	}
 
-
 	public async create(ctx: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
 		return async () => {
 			return await this.createInternal(ctx)
@@ -156,7 +157,9 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		return result
 	}
 
-	private async createInternal({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
+	private async createInternal(
+		{ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput },
+	) {
 		const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
 			[targetRelation.name]: { [entity.primary]: this.primaryValue },
 		})

package/src/mapper/update/relations/OneHasOneOwningUpdateInputProcessor.ts

@@ -18,7 +18,9 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneOwningContext
 
-export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasOneOwningUpdateInputProcessor
+	implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>
+{
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
 		private readonly mapper: Mapper,
@@ -32,7 +34,8 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		if (err) return [err]
 		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
 		const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
-		if (currentOwnerResult.some(it => it.error)
+		if (
+			currentOwnerResult.some(it => it.error)
 			|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
 		) {
 			return currentOwnerResult
@@ -66,14 +69,17 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		}
 	}
 
-	public async connectOrCreate({ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: MapperInput.ConnectOrCreateInput }) {
+	public async connectOrCreate(
+		{ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: MapperInput.ConnectOrCreateInput },
+	) {
 		const { relation, targetRelation, targetEntity, entity } = context
 		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
 		const [newInverseSide] = await this.mapper.getPrimaryValue(targetEntity, connect)
 
 		if (newInverseSide) {
 			const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
-			if (currentOwnerResult.some(it => it.error)
+			if (
+				currentOwnerResult.some(it => it.error)
 				|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
 			) {
 				return currentOwnerResult
@@ -85,7 +91,6 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 					...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
 				]
 			}
-
 		}
 
 		const createResult = await this.createInternal({ ...context, input: create }, currentInverseSide)
@@ -116,7 +121,9 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		}
 	}
 
-	public async upsert({ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput }) {
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput },
+	) {
 		const primary = await this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
 		if (!primary) {
 			const insertResult = await this.mapper.insert(targetEntity, create)
@@ -184,14 +191,22 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		return await this.mapper.insert(targetEntity, input)
 	}
 
-	private async getCurrentInverseSide(targetRelation: Model.OneHasOneInverseRelation | null, relation: Model.OneHasOneOwningRelation, entity: Model.Entity) {
+	private async getCurrentInverseSide(
+		targetRelation: Model.OneHasOneInverseRelation | null,
+		relation: Model.OneHasOneOwningRelation,
+		entity: Model.Entity,
+	) {
 		if ((targetRelation && !targetRelation.nullable) || relation.orphanRemoval) {
 			return this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
 		}
 		return undefined
 	}
 
-	private async cleanupOrphan(relation: Model.OneHasOneOwningRelation, targetEntity: Model.Entity, currentInverseSide: Input.PrimaryValue | undefined) {
+	private async cleanupOrphan(
+		relation: Model.OneHasOneOwningRelation,
+		targetEntity: Model.Entity,
+		currentInverseSide: Input.PrimaryValue | undefined,
+	) {
 		if (relation.orphanRemoval && currentInverseSide) {
 			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: currentInverseSide })
 		}
@@ -203,7 +218,6 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		currentInverseSide: Input.PrimaryValue | undefined,
 		newInverseSide: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-
 		if (currentInverseSide === newInverseSide) {
 			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
 		}

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -21,7 +21,6 @@ type NodeFilter = (node: GraphQlFieldNode, path: string[]) => boolean
 type AnyNode = ObjectNode | FieldNode
 
 export class GraphQlQueryAstFactory {
-
 	public create<Args = any>(info: GraphQLResolveInfo, filter?: NodeFilter): ObjectNode<Args> {
 		const node = ResolveInfoUtils.extractFieldNode(info)
 		const parentType = info.parentType

package/src/resolvers/MutationResolver.ts

@@ -44,11 +44,11 @@ export class MutationResolver {
 	public async resolveTransaction(info: GraphQLResolveInfo, options: TransactionOptions): Promise<Result.TransactionResult> {
 		const queryAst = this.graphqlQueryAstFactory.create(info, (node, path) => {
 			return (
-				(path.length === 1 && !['ok', 'validation', 'errorMessage', 'errors'].includes(node.name.value)) ||
-				(path.length === 2 && node.name.value === 'node') ||
-				path.length > 2 ||
-				path.length === 0 ||
-				(path.length > 1 && path[1] === 'query')
+				(path.length === 1 && !['ok', 'validation', 'errorMessage', 'errors'].includes(node.name.value))
+				|| (path.length === 2 && node.name.value === 'node')
+				|| path.length > 2
+				|| path.length === 0
+				|| (path.length > 1 && path[1] === 'query')
 			)
 		})
 		const fields = GraphQlQueryAstFactory.resolveObjectType(info.returnType).getFields()
@@ -189,7 +189,7 @@ export class MutationResolver {
 							? {
 								valid: result.validation.valid,
 								errors: validationErrors,
-							  }
+							}
 							: { valid: true, errors: [] },
 						errorMessage: [
 							this.stringifyValidationErrors(validationErrors),
@@ -429,8 +429,8 @@ export class MutationResolver {
 
 		const result = await mapper.delete(entity, queryAst.args.by, queryAst.args.filter)
 		if (
-			result.length >= 1 &&
-			(result[0].result === MutationResultType.ok || result[0].result === MutationResultType.nothingToDo)
+			result.length >= 1
+			&& (result[0].result === MutationResultType.ok || result[0].result === MutationResultType.nothingToDo)
 		) {
 			return { ok: true, errors: [], ...nodes }
 		} else {
@@ -492,7 +492,6 @@ export class MutationResolver {
 							}
 							return { ...result, ...errorResponse }
 						}
-
 					}
 					return result
 				})
@@ -504,7 +503,6 @@ export class MutationResolver {
 				maxTimeout: 1000,
 			},
 		)
-
 	}
 
 	private createErrorResponse(result: MutationResultList) {
@@ -545,7 +543,7 @@ export class MutationResolver {
 				path.map(it => ({
 					...it,
 					__typename: 'field' in it ? '_FieldPathFragment' : '_IndexPathFragment',
-				})),
+				}))
 			)
 			const path = paths[0] || []
 			switch (it.result) {
@@ -594,8 +592,8 @@ export class MutationResolver {
 			return undefined
 		}
 		return (
-			'Validation has failed:\n' +
-			validationErrors.map(it => `${this.stringifyPath(it.path)}: ${it.message.text}`).join('\n')
+			'Validation has failed:\n'
+			+ validationErrors.map(it => `${this.stringifyPath(it.path)}: ${it.message.text}`).join('\n')
 		)
 	}
 
@@ -604,8 +602,8 @@ export class MutationResolver {
 			return undefined
 		}
 		return (
-			'Execution has failed:\n' +
-			executionErrors.map(it => `${this.stringifyPath(it.paths[0] || [])}: ${it.type} (${it.message || ''})`)
+			'Execution has failed:\n'
+			+ executionErrors.map(it => `${this.stringifyPath(it.paths[0] || [])}: ${it.type} (${it.message || ''})`)
 		)
 	}
 

package/src/schema/ColumnTypeResolver.ts

@@ -93,7 +93,7 @@ export class ColumnTypeResolver {
 			case Model.ColumnType.Json:
 				return this.customTypeProvider.jsonType
 			default:
-				(({}: never): never => {
+				;(({}: never): never => {
 					throw new ImplementationException('Invalid column type')
 				})(type)
 		}

package/src/schema/ConditionTypeProvider.ts

@@ -60,6 +60,9 @@ export class ConditionTypeProvider {
 						conditions.lte = { type: type }
 						conditions.gt = { type: type }
 						conditions.gte = { type: type }
+					} else {
+						// For JSON columns, add the includes operator
+						conditions.includes = { type: type }
 					}
 					if (column.type === Model.ColumnType.String) {
 						conditions.contains = { type: GraphQLString }
@@ -72,7 +75,6 @@ export class ConditionTypeProvider {
 					}
 				}
 
-
 				return conditions
 			},
 		})

package/src/schema/CustomTypesProvider.ts

@@ -20,11 +20,10 @@ function validateTime(value: unknown): string {
 	return `${hours}:${minutes}:${seconds}${fraction}`
 }
 
-
 export class CustomTypesProvider {
 	public readonly uuidType: GraphQLScalarType = UuidType
 
-	//todo: implement serialize, parseValue and parseLiteral properly
+	// todo: implement serialize, parseValue and parseLiteral properly
 
 	public readonly dateType: GraphQLScalarType = new GraphQLScalarType({
 		name: 'Date',

package/src/schema/EntityTypeProvider.ts

@@ -77,9 +77,7 @@ export class EntityTypeProvider {
 	private getEntityFields(entityName: string) {
 		const entity = getEntityFromSchema(this.schema, entityName)
 		const accessVisitor = new FieldAccessVisitor(Acl.Operation.read, this.authorizator)
-		const accessibleFields = Object.values(entity.fields).filter(field =>
-			acceptFieldVisitor(this.schema, entity, field.name, accessVisitor),
-		)
+		const accessibleFields = Object.values(entity.fields).filter(field => acceptFieldVisitor(this.schema, entity, field.name, accessVisitor))
 		const metaFields: { [field: string]: GraphQLFieldConfig<any, any> } = {}
 		for (const field of accessibleFields) {
 			metaFields[field.name] = {

package/src/schema/GraphQlSchemaBuilder.ts

@@ -63,9 +63,7 @@ export class GraphQlSchemaBuilder {
 			queries.set('transaction', {
 				type: queryTransactionType,
 				resolve: async (parent, args, context: Context, info) => {
-					return context.timer(`GraphQL.query.${info.fieldName}`, () =>
-						context.executionContainer.readResolver.resolveTransaction(info),
-					)
+					return context.timer(`GraphQL.query.${info.fieldName}`, () => context.executionContainer.readResolver.resolveTransaction(info))
 				},
 			})
 		}
@@ -105,13 +103,17 @@ export class GraphQlSchemaBuilder {
 				type: new GraphQLNonNull(
 					mutationTransactionType,
 				),
-				resolve: async (parent, args: { options?: { deferForeignKeyConstraints?: boolean; deferUniqueConstraints?: boolean } }, context: Context, info) => {
+				resolve: async (
+					parent,
+					args: { options?: { deferForeignKeyConstraints?: boolean; deferUniqueConstraints?: boolean } },
+					context: Context,
+					info,
+				) => {
 					return context.timer(`GraphQL.mutation.${info.fieldName}`, () =>
 						context.executionContainer.mutationResolver.resolveTransaction(info, {
 							deferForeignKeyConstraints: args.options?.deferForeignKeyConstraints ?? false,
 							deferUniqueConstraints: args.options?.deferUniqueConstraints ?? false,
-						}),
-					)
+						}))
 				},
 			})
 			mutations.set('query', {
@@ -138,7 +140,6 @@ export class GraphQlSchemaBuilder {
 			}),
 		})
 
-
 		return {
 			query: queryObjectType,
 			types: args.types,

package/src/schema/GraphQlSchemaBuilderFactory.ts

@@ -32,80 +32,162 @@ import { ConnectOrCreateRelationInputProvider } from './mutations/ConnectOrCreat
 import { RefreshViewMutationProvider } from './RefreshViewMutationProvider'
 
 export class GraphQlSchemaBuilderFactory {
-	constructor() {}
-
 	public create(schema: Model.Schema, authorizator: Authorizator): GraphQlSchemaBuilder {
 		return this.createContainerBuilder(schema, authorizator).build().graphQlSchemaBuilder
 	}
 
 	public createContainerBuilder(schema: Model.Schema, authorizator: Authorizator) {
 		return new Builder({})
-			.addService('schema', () =>
-				schema)
-			.addService('authorizator', () =>
-				authorizator)
-			.addService('customTypesProvider', ({}) =>
-				new CustomTypesProvider())
-			.addService('enumsProvider', ({ schema }) =>
-				new EnumsProvider(schema))
-			.addService('columnTypeResolver', ({ schema, enumsProvider, customTypesProvider }) =>
-				new ColumnTypeResolver(schema, enumsProvider, customTypesProvider))
-			.addService('conditionTypeProvider', ({ columnTypeResolver }) =>
-				new ConditionTypeProvider(columnTypeResolver))
-			.addService('whereTypeProvider', ({ schema, authorizator, columnTypeResolver, conditionTypeProvider }) =>
-				new WhereTypeProvider(schema, authorizator, columnTypeResolver, conditionTypeProvider))
-			.addService('orderByTypeProvider', ({ schema, authorizator }) =>
-				new OrderByTypeProvider(schema, authorizator))
-			.addService('entityTypeProvider', ({ schema, authorizator, columnTypeResolver, whereTypeProvider, orderByTypeProvider }) =>
-				new EntityTypeProvider(schema, authorizator, columnTypeResolver, whereTypeProvider, orderByTypeProvider))
-			.addService('paginatedFieldConfigFactory', ({ whereTypeProvider, orderByTypeProvider, entityTypeProvider }) =>
-				new PaginatedFieldConfigFactory(whereTypeProvider, orderByTypeProvider, entityTypeProvider))
-			.addService('hasManyToOneReducerVisitor', ({ schema, authorizator, entityTypeProvider, whereTypeProvider }) =>
-				new HasManyToHasOneRelationReducerFieldVisitor(schema, authorizator, entityTypeProvider, whereTypeProvider))
-			.addService('hasManyToOneReducer', ({ schema, hasManyToOneReducerVisitor }) =>
-				new HasManyToHasOneReducer(schema, hasManyToOneReducerVisitor))
-			.addService('paginatedHasManyFieldProviderVisitor', ({ paginatedFieldConfigFactory }) =>
-				new PaginatedHasManyFieldProviderVisitor(paginatedFieldConfigFactory))
-			.addService('paginatedHasManyFieldProvider', ({ schema, paginatedHasManyFieldProviderVisitor }) =>
-				new PaginatedHasManyFieldProvider(schema, paginatedHasManyFieldProviderVisitor))
-			.addService('queryProvider', ({ authorizator, whereTypeProvider, orderByTypeProvider, entityTypeProvider, paginatedFieldConfigFactory }) =>
-				new QueryProvider(authorizator, whereTypeProvider, orderByTypeProvider, entityTypeProvider, paginatedFieldConfigFactory))
-			.addService('createEntityInputProviderAccessor', ({}) =>
-				new Accessor<EntityInputProvider<EntityInputType.create>>())
-			.addService('createEntityRelationAllowedOperationsVisitor', ({ authorizator }) =>
-				new CreateEntityRelationAllowedOperationsVisitor(authorizator))
-			.addService('connectOrCreateRelationInputProvider', ({ schema, whereTypeProvider, createEntityInputProviderAccessor }) =>
-				 new ConnectOrCreateRelationInputProvider(schema, whereTypeProvider, createEntityInputProviderAccessor))
-			.addService('createEntityRelationInputFieldVisitor', ({ schema,	whereTypeProvider, createEntityInputProviderAccessor, createEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider }) =>
-				new CreateEntityRelationInputFieldVisitor(schema, whereTypeProvider, createEntityInputProviderAccessor, createEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider))
-			.addService('createEntityRelationInputProvider', ({ schema, createEntityRelationInputFieldVisitor }) =>
-				new CreateEntityRelationInputProvider(schema, createEntityRelationInputFieldVisitor))
-			.addService('createEntityInputFieldVisitor', ({ schema, authorizator, columnTypeResolver, createEntityRelationInputProvider }) =>
-				new CreateEntityInputFieldVisitor(schema, authorizator, columnTypeResolver, createEntityRelationInputProvider))
-			.addService('createEntityInputProvider', ({ schema, authorizator, createEntityInputFieldVisitor }) =>
-				new EntityInputProvider(EntityInputType.create, schema, authorizator, createEntityInputFieldVisitor))
-			.addService('updateEntityInputProviderAccessor', ({}) =>
-				new Accessor<EntityInputProvider<EntityInputType.update>>())
-			.addService('updateEntityRelationAllowedOperationsVisitor', ({ authorizator }) =>
-				new UpdateEntityRelationAllowedOperationsVisitor(authorizator))
-			.addService('updateEntityRelationInputFieldVisitor', ({ schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider }) =>
-				new UpdateEntityRelationInputFieldVisitor(schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider))
-			.addService('updateEntityRelationInputProvider', ({ schema, updateEntityRelationInputFieldVisitor }) =>
-				new UpdateEntityRelationInputProvider(schema, updateEntityRelationInputFieldVisitor))
-			.addService('updateEntityInputFieldVisitor', ({ authorizator, columnTypeResolver, updateEntityRelationInputProvider }) =>
-				new UpdateEntityInputFieldVisitor(authorizator, columnTypeResolver, updateEntityRelationInputProvider))
-			.addService('updateEntityInputProvider', ({ schema, authorizator, updateEntityInputFieldVisitor }) =>
-				new EntityInputProvider(EntityInputType.update, schema, authorizator, updateEntityInputFieldVisitor))
-			.addService('resultSchemaTypeProvider', ({}) =>
-				new ResultSchemaTypeProvider())
-			.addService('mutationProvider', ({ authorizator, whereTypeProvider, entityTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider }) =>
-				new MutationProvider(authorizator, whereTypeProvider, entityTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider))
-			.addService('validationQueriesProvider', ({ whereTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider }) =>
-				new ValidationQueriesProvider(whereTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider))
-			.addService('refreshViewMutationProvider', ({ schema, authorizator }) =>
-				new RefreshViewMutationProvider(schema, authorizator))
-			.addService('graphQlSchemaBuilder', ({ schema, queryProvider, validationQueriesProvider, mutationProvider, resultSchemaTypeProvider, refreshViewMutationProvider }) =>
-				new GraphQlSchemaBuilder(schema, queryProvider, validationQueriesProvider, mutationProvider, resultSchemaTypeProvider, refreshViewMutationProvider))
+			.addService('schema', () => schema)
+			.addService('authorizator', () => authorizator)
+			.addService('customTypesProvider', ({}) => new CustomTypesProvider())
+			.addService('enumsProvider', ({ schema }) => new EnumsProvider(schema))
+			.addService(
+				'columnTypeResolver',
+				({ schema, enumsProvider, customTypesProvider }) => new ColumnTypeResolver(schema, enumsProvider, customTypesProvider),
+			)
+			.addService('conditionTypeProvider', ({ columnTypeResolver }) => new ConditionTypeProvider(columnTypeResolver))
+			.addService(
+				'whereTypeProvider',
+				({ schema, authorizator, columnTypeResolver, conditionTypeProvider }) =>
+					new WhereTypeProvider(schema, authorizator, columnTypeResolver, conditionTypeProvider),
+			)
+			.addService('orderByTypeProvider', ({ schema, authorizator }) => new OrderByTypeProvider(schema, authorizator))
+			.addService(
+				'entityTypeProvider',
+				({ schema, authorizator, columnTypeResolver, whereTypeProvider, orderByTypeProvider }) =>
+					new EntityTypeProvider(schema, authorizator, columnTypeResolver, whereTypeProvider, orderByTypeProvider),
+			)
+			.addService(
+				'paginatedFieldConfigFactory',
+				({ whereTypeProvider, orderByTypeProvider, entityTypeProvider }) =>
+					new PaginatedFieldConfigFactory(whereTypeProvider, orderByTypeProvider, entityTypeProvider),
+			)
+			.addService(
+				'hasManyToOneReducerVisitor',
+				({ schema, authorizator, entityTypeProvider, whereTypeProvider }) =>
+					new HasManyToHasOneRelationReducerFieldVisitor(schema, authorizator, entityTypeProvider, whereTypeProvider),
+			)
+			.addService('hasManyToOneReducer', ({ schema, hasManyToOneReducerVisitor }) => new HasManyToHasOneReducer(schema, hasManyToOneReducerVisitor))
+			.addService(
+				'paginatedHasManyFieldProviderVisitor',
+				({ paginatedFieldConfigFactory }) => new PaginatedHasManyFieldProviderVisitor(paginatedFieldConfigFactory),
+			)
+			.addService(
+				'paginatedHasManyFieldProvider',
+				({ schema, paginatedHasManyFieldProviderVisitor }) => new PaginatedHasManyFieldProvider(schema, paginatedHasManyFieldProviderVisitor),
+			)
+			.addService(
+				'queryProvider',
+				({ authorizator, whereTypeProvider, orderByTypeProvider, entityTypeProvider, paginatedFieldConfigFactory }) =>
+					new QueryProvider(authorizator, whereTypeProvider, orderByTypeProvider, entityTypeProvider, paginatedFieldConfigFactory),
+			)
+			.addService('createEntityInputProviderAccessor', ({}) => new Accessor<EntityInputProvider<EntityInputType.create>>())
+			.addService('createEntityRelationAllowedOperationsVisitor', ({ authorizator }) => new CreateEntityRelationAllowedOperationsVisitor(authorizator))
+			.addService(
+				'connectOrCreateRelationInputProvider',
+				({ schema, whereTypeProvider, createEntityInputProviderAccessor }) =>
+					new ConnectOrCreateRelationInputProvider(schema, whereTypeProvider, createEntityInputProviderAccessor),
+			)
+			.addService(
+				'createEntityRelationInputFieldVisitor',
+				({
+					schema,
+					whereTypeProvider,
+					createEntityInputProviderAccessor,
+					createEntityRelationAllowedOperationsVisitor,
+					connectOrCreateRelationInputProvider,
+				}) =>
+					new CreateEntityRelationInputFieldVisitor(
+						schema,
+						whereTypeProvider,
+						createEntityInputProviderAccessor,
+						createEntityRelationAllowedOperationsVisitor,
+						connectOrCreateRelationInputProvider,
+					),
+			)
+			.addService(
+				'createEntityRelationInputProvider',
+				({ schema, createEntityRelationInputFieldVisitor }) => new CreateEntityRelationInputProvider(schema, createEntityRelationInputFieldVisitor),
+			)
+			.addService(
+				'createEntityInputFieldVisitor',
+				({ schema, authorizator, columnTypeResolver, createEntityRelationInputProvider }) =>
+					new CreateEntityInputFieldVisitor(schema, authorizator, columnTypeResolver, createEntityRelationInputProvider),
+			)
+			.addService(
+				'createEntityInputProvider',
+				({ schema, authorizator, createEntityInputFieldVisitor }) =>
+					new EntityInputProvider(EntityInputType.create, schema, authorizator, createEntityInputFieldVisitor),
+			)
+			.addService('updateEntityInputProviderAccessor', ({}) => new Accessor<EntityInputProvider<EntityInputType.update>>())
+			.addService('updateEntityRelationAllowedOperationsVisitor', ({ authorizator }) => new UpdateEntityRelationAllowedOperationsVisitor(authorizator))
+			.addService(
+				'updateEntityRelationInputFieldVisitor',
+				({
+					schema,
+					authorizator,
+					whereTypeProvider,
+					updateEntityInputProviderAccessor,
+					createEntityInputProvider,
+					updateEntityRelationAllowedOperationsVisitor,
+					connectOrCreateRelationInputProvider,
+				}) =>
+					new UpdateEntityRelationInputFieldVisitor(
+						schema,
+						authorizator,
+						whereTypeProvider,
+						updateEntityInputProviderAccessor,
+						createEntityInputProvider,
+						updateEntityRelationAllowedOperationsVisitor,
+						connectOrCreateRelationInputProvider,
+					),
+			)
+			.addService(
+				'updateEntityRelationInputProvider',
+				({ schema, updateEntityRelationInputFieldVisitor }) => new UpdateEntityRelationInputProvider(schema, updateEntityRelationInputFieldVisitor),
+			)
+			.addService(
+				'updateEntityInputFieldVisitor',
+				({ authorizator, columnTypeResolver, updateEntityRelationInputProvider }) =>
+					new UpdateEntityInputFieldVisitor(authorizator, columnTypeResolver, updateEntityRelationInputProvider),
+			)
+			.addService(
+				'updateEntityInputProvider',
+				({ schema, authorizator, updateEntityInputFieldVisitor }) =>
+					new EntityInputProvider(EntityInputType.update, schema, authorizator, updateEntityInputFieldVisitor),
+			)
+			.addService('resultSchemaTypeProvider', ({}) => new ResultSchemaTypeProvider())
+			.addService(
+				'mutationProvider',
+				({ authorizator, whereTypeProvider, entityTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider }) =>
+					new MutationProvider(
+						authorizator,
+						whereTypeProvider,
+						entityTypeProvider,
+						createEntityInputProvider,
+						updateEntityInputProvider,
+						resultSchemaTypeProvider,
+					),
+			)
+			.addService(
+				'validationQueriesProvider',
+				({ whereTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider }) =>
+					new ValidationQueriesProvider(whereTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider),
+			)
+			.addService('refreshViewMutationProvider', ({ schema, authorizator }) => new RefreshViewMutationProvider(schema, authorizator))
+			.addService(
+				'graphQlSchemaBuilder',
+				({ schema, queryProvider, validationQueriesProvider, mutationProvider, resultSchemaTypeProvider, refreshViewMutationProvider }) =>
+					new GraphQlSchemaBuilder(
+						schema,
+						queryProvider,
+						validationQueriesProvider,
+						mutationProvider,
+						resultSchemaTypeProvider,
+						refreshViewMutationProvider,
+					),
+			)
 			.setupService('createEntityInputProvider', (it, { createEntityInputProviderAccessor }) => {
 				createEntityInputProviderAccessor.set(it)
 			})