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

package/dist/tests/cases/integration/graphQlSchema/schema-view-entity.gql

@@ -1,112 +0,0 @@
-type Query {
-  getAuthor(by: AuthorUniqueWhere!, filter: AuthorWhere): Author
-  listAuthor(filter: AuthorWhere, orderBy: [AuthorOrderBy!], offset: Int, limit: Int): [Author!]!
-  paginateAuthor(filter: AuthorWhere, orderBy: [AuthorOrderBy!], skip: Int, first: Int): AuthorConnection!
-  transaction: QueryTransaction
-  _info: Info
-}
-
-type Author {
-  _meta: AuthorMeta
-  id: UUID!
-  name: String
-}
-
-type AuthorMeta {
-  id: FieldMeta
-  name: FieldMeta
-}
-
-type FieldMeta {
-  readable: Boolean
-  updatable: Boolean
-}
-
-scalar UUID
-
-input AuthorUniqueWhere {
-  id: UUID
-}
-
-input AuthorWhere {
-  id: UUIDCondition
-  name: StringCondition
-  and: [AuthorWhere]
-  or: [AuthorWhere]
-  not: AuthorWhere
-}
-
-input UUIDCondition {
-  and: [UUIDCondition!]
-  or: [UUIDCondition!]
-  not: UUIDCondition
-  null: Boolean
-  isNull: Boolean
-  eq: UUID
-  notEq: UUID
-  in: [UUID!]
-  notIn: [UUID!]
-  lt: UUID
-  lte: UUID
-  gt: UUID
-  gte: UUID
-}
-
-input StringCondition {
-  and: [StringCondition!]
-  or: [StringCondition!]
-  not: StringCondition
-  null: Boolean
-  isNull: Boolean
-  eq: String
-  notEq: String
-  in: [String!]
-  notIn: [String!]
-  lt: String
-  lte: String
-  gt: String
-  gte: String
-  contains: String
-  startsWith: String
-  endsWith: String
-  containsCI: String
-  startsWithCI: String
-  endsWithCI: String
-}
-
-input AuthorOrderBy {
-  _random: Boolean
-  _randomSeeded: Int
-  id: OrderDirection
-  name: OrderDirection
-}
-
-enum OrderDirection {
-  asc
-  desc
-  ascNullsFirst
-  descNullsLast
-}
-
-type AuthorConnection {
-  pageInfo: PageInfo!
-  edges: [AuthorEdge!]!
-}
-
-type PageInfo {
-  totalCount: Int!
-}
-
-type AuthorEdge {
-  node: Author!
-}
-
-type QueryTransaction {
-  getAuthor(by: AuthorUniqueWhere!, filter: AuthorWhere): Author
-  listAuthor(filter: AuthorWhere, orderBy: [AuthorOrderBy!], offset: Int, limit: Int): [Author!]!
-  paginateAuthor(filter: AuthorWhere, orderBy: [AuthorOrderBy!], skip: Int, first: Int): AuthorConnection!
-}
-
-type Info {
-  description: String
-}

package/src/acl/PermissionsByIdentityFactory.ts

@@ -1,21 +0,0 @@
-import { PermissionFactory } from './PermissionFactory'
-import { arrayEquals } from '../utils'
-import { Acl, Schema } from '@contember/schema'
-
-export class PermissionsByIdentityFactory {
-	public createPermissions(schema: Schema, identity: Identity): PermissionResult {
-		return {
-			permissions: new PermissionFactory(schema.model).create(schema.acl, identity.projectRoles),
-			verifier: otherIdentity => arrayEquals(identity.projectRoles, otherIdentity.projectRoles),
-		}
-	}
-}
-
-export interface Identity {
-	projectRoles: string[]
-}
-
-export interface PermissionResult {
-	permissions: Acl.Permissions
-	verifier: (identity: Identity) => boolean
-}

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')
-	}
-}

package/src/utils/arrays.ts

@@ -1,19 +0,0 @@
-const arrayEquals = (a: unknown[] | null, b: unknown[] | null): boolean => {
-	if (a === b) {
-		return true
-	}
-	if (a === null || b === null) {
-		return false
-	}
-	if (a.length !== b.length) {
-		return false
-	}
-	for (let i = 0; i < a.length; ++i) {
-		if (a[i] !== b[i]) {
-			return false
-		}
-	}
-	return true
-}
-
-export { arrayEquals }