@contember/engine-content-api 1.3.0-alpha.1 → 1.3.0-alpha.4

package/src/mapper/MapperContainer.ts

@@ -1,142 +0,0 @@
-import { PredicateFactory, PredicatesInjector, VariableInjector } from '../acl'
-import {
-	ConditionBuilder,
-	FieldsVisitorFactory,
-	JoinBuilder,
-	MetaHandler,
-	OrderByBuilder,
-	RelationFetcher,
-	WhereBuilder,
-} from './select'
-import { UniqueWhereExpander } from '../inputProcessing'
-import { HasManyToHasOneReducer, HasManyToHasOneReducerExecutionHandler } from '../extensions'
-import {
-	DeleteExecutor,
-	InsertBuilderFactory,
-	Inserter,
-	JunctionConnectHandler,
-	JunctionDisconnectHandler,
-	JunctionTableManager,
-	Mapper,
-	MapperFactory,
-	PathFactory,
-	SelectBuilder,
-	SelectBuilderFactory,
-	SelectHydrator,
-	UpdateBuilderFactory,
-	Updater,
-} from '../mapper'
-import { Builder } from '@contember/dic'
-import { Acl, Model, Schema } from '@contember/schema'
-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
-	identityVariables: Acl.VariablesMap
-	permissions: Acl.Permissions
-	providers: Providers
-}
-
-export interface MapperContainer {
-	mapperFactory: MapperFactory
-}
-
-export const createMapperContainer = ({ permissions, schema, identityVariables, providers }: MapperContainerArgs) => {
-	const builder = new Builder({})
-		.addService('providers', () =>
-			providers)
-		.addService('variableInjector', () =>
-			new VariableInjector(schema.model, identityVariables))
-		.addService('predicateFactory', ({ variableInjector }) =>
-			new PredicateFactory(permissions, schema.model, variableInjector))
-		.addService('predicatesInjector', ({ predicateFactory }) =>
-			new PredicatesInjector(schema.model, predicateFactory))
-		.addService('joinBuilder', () =>
-			new JoinBuilder(schema.model))
-		.addService('conditionBuilder', () =>
-			new ConditionBuilder())
-		.addService('pathFactory', () =>
-			new PathFactory())
-		.addService('whereOptimized', () =>
-			new WhereOptimizer(schema.model, new ConditionOptimizer()))
-		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized }) =>
-			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema.settings.useExistsInHasManyFilter === true))
-		.addService('orderByBuilder', ({ joinBuilder }) =>
-			new OrderByBuilder(schema.model, joinBuilder))
-		.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
-			new RelationFetcher(whereBuilder, orderByBuilder, predicatesInjector, pathFactory))
-		.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, whereBuilder }) =>
-			new FieldsVisitorFactory(schema.model, relationFetcher, predicateFactory, whereBuilder))
-		.addService('metaHandler', ({ whereBuilder, predicateFactory }) =>
-			new MetaHandler(whereBuilder, predicateFactory))
-		.addService('uniqueWhereExpander', () =>
-			new UniqueWhereExpander(schema.model))
-		.addService('hasManyToHasOneReducer', ({ uniqueWhereExpander }) =>
-			new HasManyToHasOneReducerExecutionHandler(schema.model, uniqueWhereExpander))
-		.addService('paginatedHasManyExecutionHandler', ({ relationFetcher }) =>
-			new PaginatedHasManyExecutionHandler(schema.model, relationFetcher))
-		.addService('selectHandlers', ({ hasManyToHasOneReducer, paginatedHasManyExecutionHandler }) => ({
-			[HasManyToHasOneReducer.extensionName]: hasManyToHasOneReducer,
-			[PaginatedHasManyFieldProvider.extensionName]: paginatedHasManyExecutionHandler,
-		}))
-		.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory, predicateFactory }) =>
-			new (class implements SelectBuilderFactory {
-				create(qb: DbSelectBuilder, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder {
-					return new SelectBuilder(
-						schema.model,
-						whereBuilder,
-						orderByBuilder,
-						metaHandler,
-						qb,
-						hydrator,
-						fieldsVisitorFactory,
-						selectHandlers,
-						pathFactory,
-						relationPath,
-						predicateFactory,
-					)
-				}
-			})())
-		.addService(
-			'insertBuilderFactory',
-			({ whereBuilder, pathFactory, predicateFactory }) =>
-				new InsertBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory),
-		)
-		.addService(
-			'updateBuilderFactory',
-			({ whereBuilder, pathFactory, predicateFactory }) =>
-				new UpdateBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
-		.addService('connectJunctionHandler', () =>
-			new JunctionConnectHandler())
-		.addService('disconnectJunctionHandler', ({}) =>
-			new JunctionDisconnectHandler())
-		.addService('junctionTableManager', ({ predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory }) =>
-			new JunctionTableManager(schema.model, predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory))
-		.addService('deleteExecutor', ({ predicateFactory, updateBuilderFactory, whereBuilder, pathFactory }) =>
-			new DeleteExecutor(schema.model, predicateFactory, whereBuilder, updateBuilderFactory, pathFactory))
-		.addService('updater', ({ predicateFactory, updateBuilderFactory }) =>
-			new Updater(schema.model, predicateFactory, updateBuilderFactory))
-		.addService('inserter', ({ insertBuilderFactory, providers }) => new Inserter(schema.model, insertBuilderFactory, providers))
-		.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory }) => {
-			return (db: Client) =>
-				new Mapper(
-					schema.model,
-					db,
-					predicatesInjector,
-					selectBuilderFactory,
-					uniqueWhereExpander,
-					whereBuilder,
-					junctionTableManager,
-					deleteExecutor,
-					updater,
-					inserter,
-					pathFactory,
-				)
-		})
-	return builder.build().pick('mapperFactory')
-}

package/src/resolvers/ExecutionContainerFactory.ts

@@ -1,74 +0,0 @@
-import { Builder, Container } from '@contember/dic'
-import { Acl, Schema } from '@contember/schema'
-import { Context } from '../types'
-import { ReadResolver } from './ReadResolver'
-import { MutationResolver } from './MutationResolver'
-import { Client } from '@contember/database'
-import {
-	ColumnValueResolver,
-	DependencyCollector,
-	EntityRulesResolver,
-	InputPreValidator,
-	QueryAstFactory,
-	ValidationDataSelector,
-} from '../input-validation'
-import { ValidationResolver } from './ValidationResolver'
-import { Providers } from '@contember/schema-utils'
-import { GraphQlQueryAstFactory } from './GraphQlQueryAstFactory'
-import { getArgumentValues } from 'graphql'
-import { createMapperContainer } from '../mapper'
-
-export interface ExecutionContainer {
-	readResolver: ReadResolver
-	mutationResolver: MutationResolver
-	validationResolver: ValidationResolver
-}
-
-export class ExecutionContainerFactory {
-	constructor(
-		private readonly schema: Schema,
-		private readonly permissions: Acl.Permissions,
-		private readonly providers: Providers,
-		private readonly argumentValuesResolver: typeof getArgumentValues,
-		private readonly setupSystemVariables: (db: Client) => Promise<void>,
-	) {}
-
-	public create(context: Pick<Context, 'db' | 'identityVariables'>): Container<ExecutionContainer> {
-		const mapperContainer = createMapperContainer({
-			permissions: this.permissions,
-			identityVariables: context.identityVariables,
-			providers: this.providers,
-			schema: this.schema,
-		})
-		const innerDic = new Builder({})
-			.addService('db', () =>
-				context.db)
-			.addService('providers', () =>
-				this.providers)
-			.addService('mapperFactory', () =>
-				mapperContainer.mapperFactory)
-			.addService('queryAstFactory', () =>
-				new GraphQlQueryAstFactory(this.argumentValuesResolver))
-			.addService('readResolver', ({ db, mapperFactory, queryAstFactory }) =>
-				new ReadResolver(db, mapperFactory, queryAstFactory))
-			.addService('validationDependencyCollector', () =>
-				new DependencyCollector())
-			.addService('validationQueryAstFactory', () =>
-				new QueryAstFactory(this.schema.model))
-			.addService('dataSelector', ({ validationQueryAstFactory }) =>
-				new ValidationDataSelector(this.schema.model, validationQueryAstFactory))
-			.addService('columnValueResolver', ({ providers }) =>
-				new ColumnValueResolver(providers))
-			.addService('entityRulesResolver', () =>
-				new EntityRulesResolver(this.schema.validation, this.schema.model))
-			.addService('inputPreValidator', ({ entityRulesResolver, columnValueResolver, dataSelector }) =>
-				new InputPreValidator(this.schema.model, entityRulesResolver, columnValueResolver, dataSelector))
-			.addService('mutationResolver', ({ db, mapperFactory, inputPreValidator, queryAstFactory }) =>
-				new MutationResolver(this.schema.model, db, mapperFactory, this.setupSystemVariables, inputPreValidator, queryAstFactory))
-			.addService('validationResolver', ({ inputPreValidator, db, mapperFactory }) =>
-				new ValidationResolver(db, mapperFactory, inputPreValidator))
-			.build()
-
-		return innerDic.pick('readResolver', 'mutationResolver', 'validationResolver')
-	}
-}