@contember/engine-content-api 2.1.0-alpha.3 → 2.1.0-alpha.35

package/graphql.codegen.yml

@@ -12,4 +12,4 @@ generates:
       - "typescript-operations"
 hooks:
   afterAllFileWrite:
-    - bun run -T eslint --fix
+    - bunx biome lint --write

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "2.1.0-alpha.3",
+  "version": "2.1.0-alpha.35",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -26,25 +26,30 @@
     "generate": "gql-gen --config graphql.codegen.yml"
   },
   "dependencies": {
-    "@contember/database": "2.1.0-alpha.3",
-    "@contember/dic": "2.1.0-alpha.3",
-    "@contember/graphql-utils": "2.1.0-alpha.3",
-    "@contember/logger": "2.1.0-alpha.3",
-    "@contember/schema": "2.1.0-alpha.3",
-    "@contember/schema-definition": "2.1.0-alpha.3",
-    "@contember/schema-utils": "2.1.0-alpha.3",
-    "fast-deep-equal": "^3.1.3"
+    "@contember/database": "workspace:*",
+    "@contember/dic": "workspace:*",
+    "@contember/graphql-utils": "workspace:*",
+    "@contember/logger": "workspace:*",
+    "@contember/schema": "workspace:*",
+    "@contember/schema-definition": "workspace:*",
+    "@contember/schema-utils": "workspace:*",
+    "fast-deep-equal": "catalog:"
   },
   "devDependencies": {
-    "@contember/database-tester": "2.1.0-alpha.3",
-    "@contember/schema-definition": "2.1.0-alpha.3",
-    "@types/node": "^20.17.22",
-    "graphql": "^16.9.0",
-    "pg": "^8.12.0"
+    "@contember/database-tester": "workspace:*",
+    "@contember/schema-definition": "workspace:*",
+    "@types/node": "catalog:",
+    "graphql": "catalog:",
+    "pg": "catalog:"
   },
   "peerDependencies": {
-    "graphql": ">= 14.6.0",
-    "pg": "^8.9.0"
+    "graphql": "catalog:",
+    "pg": "catalog:"
   },
-  "type": "module"
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/contember/contember.git",
+    "directory": "packages/engine-content-api"
+  }
 }

package/src/ExecutionContainer.ts

@@ -1,13 +1,5 @@
 import { PredicateFactory, PredicatesInjector, VariableInjector } from './acl'
-import {
-	ConditionBuilder,
-	FieldsVisitorFactory,
-	JoinBuilder,
-	MetaHandler,
-	OrderByBuilder,
-	RelationFetcher,
-	WhereBuilder,
-} from './mapper/select'
+import { ConditionBuilder, FieldsVisitorFactory, JoinBuilder, MetaHandler, OrderByBuilder, RelationFetcher, WhereBuilder } from './mapper/select'
 import { UniqueWhereExpander } from './inputProcessing'
 import { HasManyToHasOneReducer, HasManyToHasOneReducerExecutionHandler } from './extensions'
 import {
@@ -31,13 +23,14 @@ import { Client, DatabaseMetadata, SelectBuilder as DbSelectBuilder } from '@con
 import { ParsedMembership, Providers } from '@contember/schema-utils'
 import { PaginatedHasManyExecutionHandler } from './extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
 import { PaginatedHasManyFieldProvider } from './extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
-import { WhereOptimizer } from './mapper/select/optimizer/WhereOptimizer'
+import { WhereOptimizer, WhereOptimizerOptions } from './mapper/select/optimizer/WhereOptimizer'
 import { ConditionOptimizer } from './mapper/select/optimizer/ConditionOptimizer'
 import { GraphQlQueryAstFactory, MutationResolver, ReadResolver, ValidationResolver } from './resolvers'
 import {
 	ColumnValueResolver,
 	DependencyCollector,
-	EntityRulesResolver, InputPreValidator,
+	EntityRulesResolver,
+	InputPreValidator,
 	QueryAstFactory,
 	ValidationDataSelector,
 } from './input-validation'
@@ -54,6 +47,7 @@ export type ExecutionContainerArgs = {
 	systemSchema: string
 	project: { slug: string }
 	stage: { id: string; slug: string }
+	userInfo: { ipAddress: string | null; userAgent: string | null }
 }
 
 export interface ExecutionContainer {
@@ -71,6 +65,7 @@ export class ExecutionContainerFactory {
 
 	constructor(
 		private readonly providers: Providers,
+		private readonly whereOptimizerOptions?: WhereOptimizerOptions,
 	) {
 	}
 
@@ -79,38 +74,27 @@ export class ExecutionContainerFactory {
 		return this.hooks.reduce((acc, cb) => cb(acc), builder)
 	}
 
-	createBuilderInternal({ permissions, identityVariables, identityId, db, schema, schemaMeta, systemSchema, stage, project, schemaDatabaseMetadata }: ExecutionContainerArgs) {
+	createBuilderInternal(
+		{ permissions, identityVariables, identityId, db, schema, schemaMeta, systemSchema, stage, project, schemaDatabaseMetadata, userInfo }:
+			ExecutionContainerArgs,
+	) {
 		return new Builder({})
-			.addService('systemSchema', () =>
-				systemSchema)
-			.addService('db', () =>
-				db)
-			.addService('project', () =>
-				project)
-			.addService('stage', () =>
-				stage)
-			.addService('schema', () =>
-				schema)
-			.addService('schemaMeta', () =>
-				schemaMeta)
-			.addService('schemaDatabaseMetadata', () =>
-				schemaDatabaseMetadata)
-			.addService('providers', () =>
-				this.providers)
-			.addService('variableInjector', ({ schema }) =>
-				new VariableInjector(schema.model, identityVariables))
-			.addService('predicateFactory', ({ variableInjector, schema }) =>
-				new PredicateFactory(permissions, schema.model, variableInjector))
-			.addService('predicatesInjector', ({ predicateFactory, schema }) =>
-				new PredicatesInjector(schema.model, predicateFactory))
-			.addService('joinBuilder', ({ schema }) =>
-				new JoinBuilder(schema.model))
-			.addService('conditionBuilder', () =>
-				new ConditionBuilder())
-			.addService('pathFactory', () =>
-				new PathFactory())
-			.addService('whereOptimized', ({ schema }) =>
-				new WhereOptimizer(schema.model, new ConditionOptimizer()))
+			.addService('systemSchema', () => systemSchema)
+			.addService('db', () => db)
+			.addService('project', () => project)
+			.addService('stage', () => stage)
+			.addService('schema', () => schema)
+			.addService('schemaMeta', () => schemaMeta)
+			.addService('schemaDatabaseMetadata', () => schemaDatabaseMetadata)
+			.addService('userInfo', () => userInfo)
+			.addService('providers', () => this.providers)
+			.addService('variableInjector', ({ schema }) => new VariableInjector(schema.model, identityVariables))
+			.addService('predicateFactory', ({ variableInjector, schema }) => new PredicateFactory(permissions, schema.model, variableInjector))
+			.addService('predicatesInjector', ({ predicateFactory, schema }) => new PredicatesInjector(schema.model, predicateFactory))
+			.addService('joinBuilder', ({ schema }) => new JoinBuilder(schema.model))
+			.addService('conditionBuilder', () => new ConditionBuilder())
+			.addService('pathFactory', () => new PathFactory())
+			.addService('whereOptimized', ({ schema }) => new WhereOptimizer(schema.model, new ConditionOptimizer(), this.whereOptimizerOptions))
 			.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema }) =>
 				new WhereBuilder(
 					schema.model,
@@ -120,64 +104,81 @@ export class ExecutionContainerFactory {
 					whereOptimized,
 					(schema.settings.content?.useExistsInHasManyFilter ?? schema.settings.useExistsInHasManyFilter) === true,
 				))
-			.addService('orderByBuilder', ({ joinBuilder, schema }) =>
-				new OrderByBuilder(schema.model, joinBuilder))
-			.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
-				new RelationFetcher(whereBuilder, orderByBuilder, predicatesInjector, pathFactory))
-			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, schema, providers }) =>
-				new FieldsVisitorFactory(schema.model, relationFetcher, predicateFactory, schema.settings.content ?? {}, providers))
-			.addService('metaHandler', ({ whereBuilder, predicateFactory }) =>
-				new MetaHandler(whereBuilder, predicateFactory))
-			.addService('uniqueWhereExpander', ({ schema }) =>
-				new UniqueWhereExpander(schema.model))
-			.addService('hasManyToHasOneReducer', ({ uniqueWhereExpander, schema }) =>
-				new HasManyToHasOneReducerExecutionHandler(schema.model, uniqueWhereExpander))
-			.addService('paginatedHasManyExecutionHandler', ({ relationFetcher, schema }) =>
-				new PaginatedHasManyExecutionHandler(schema.model, relationFetcher))
+			.addService('orderByBuilder', ({ joinBuilder, schema }) => new OrderByBuilder(schema.model, joinBuilder))
+			.addService(
+				'relationFetcher',
+				({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
+					new RelationFetcher(whereBuilder, orderByBuilder, predicatesInjector, pathFactory),
+			)
+			.addService(
+				'fieldsVisitorFactory',
+				({ relationFetcher, predicateFactory, schema, providers }) =>
+					new FieldsVisitorFactory(schema.model, relationFetcher, predicateFactory, schema.settings.content ?? {}, providers),
+			)
+			.addService('metaHandler', ({ whereBuilder, predicateFactory }) => new MetaHandler(whereBuilder, predicateFactory))
+			.addService('uniqueWhereExpander', ({ schema }) => new UniqueWhereExpander(schema.model))
+			.addService(
+				'hasManyToHasOneReducer',
+				({ uniqueWhereExpander, schema }) => new HasManyToHasOneReducerExecutionHandler(schema.model, uniqueWhereExpander),
+			)
+			.addService(
+				'paginatedHasManyExecutionHandler',
+				({ relationFetcher, schema }) => new PaginatedHasManyExecutionHandler(schema.model, relationFetcher),
+			)
 			.addService('selectHandlers', ({ hasManyToHasOneReducer, paginatedHasManyExecutionHandler }) => ({
 				[HasManyToHasOneReducer.extensionName]: hasManyToHasOneReducer,
 				[PaginatedHasManyFieldProvider.extensionName]: paginatedHasManyExecutionHandler,
 			}))
-			.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory, predicateFactory, schema }) =>
-				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, schema, predicateFactory }) =>
-				new InsertBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
-			.addService('updateBuilderFactory', ({ whereBuilder, pathFactory, schema, predicateFactory }) =>
-				new UpdateBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
-			.addService('connectJunctionHandler', () =>
-				new JunctionConnectHandler())
-			.addService('disconnectJunctionHandler', ({}) =>
-				new JunctionDisconnectHandler())
-			.addService('junctionTableManager', ({ predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory, schema }) =>
-				new JunctionTableManager(schema.model, predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory))
-			.addService('deleteExecutor', ({ predicateFactory, updateBuilderFactory, whereBuilder, pathFactory, schema }) =>
-				new DeleteExecutor(schema.model, predicateFactory, whereBuilder, updateBuilderFactory, pathFactory))
-			.addService('updater', ({ predicateFactory, updateBuilderFactory, schema, schemaDatabaseMetadata }) =>
-				new Updater(schema.model, schemaDatabaseMetadata, predicateFactory, updateBuilderFactory))
-			.addService('inserter', ({  insertBuilderFactory, providers, schema, schemaDatabaseMetadata }) =>
-				new Inserter(schema.model, schemaDatabaseMetadata, insertBuilderFactory, providers, { uuidVersion: schema.settings.content?.uuidVersion }))
-			.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory, providers, schema, schemaDatabaseMetadata }) => {
-				return new MapperFactory(
-					db,
-					identityId,
-					schema.model,
-					schemaDatabaseMetadata,
+			.addService(
+				'selectBuilderFactory',
+				({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory, predicateFactory, schema }) =>
+					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, schema, predicateFactory }) => new InsertBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory),
+			)
+			.addService(
+				'updateBuilderFactory',
+				({ whereBuilder, pathFactory, schema, predicateFactory }) => new UpdateBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory),
+			)
+			.addService('connectJunctionHandler', () => new JunctionConnectHandler())
+			.addService('disconnectJunctionHandler', ({}) => new JunctionDisconnectHandler())
+			.addService(
+				'junctionTableManager',
+				({ predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory, schema }) =>
+					new JunctionTableManager(schema.model, predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory),
+			)
+			.addService(
+				'deleteExecutor',
+				({ predicateFactory, updateBuilderFactory, whereBuilder, pathFactory, schema }) =>
+					new DeleteExecutor(schema.model, predicateFactory, whereBuilder, updateBuilderFactory, pathFactory),
+			)
+			.addService('updater', ({ updateBuilderFactory, schema }) => new Updater(schema.model, updateBuilderFactory))
+			.addService(
+				'inserter',
+				({ insertBuilderFactory, providers, schema, schemaDatabaseMetadata }) =>
+					new Inserter(schema.model, schemaDatabaseMetadata, insertBuilderFactory, providers, { uuidVersion: schema.settings.content?.uuidVersion }),
+			)
+			.addService(
+				'mapperFactory',
+				({
 					predicatesInjector,
 					selectBuilderFactory,
 					uniqueWhereExpander,
@@ -188,35 +189,49 @@ export class ExecutionContainerFactory {
 					inserter,
 					pathFactory,
 					providers,
-				)
-			})
-
-			.addService('queryAstFactory', () =>
-				new GraphQlQueryAstFactory())
-			.addService('readResolver', ({ mapperFactory, queryAstFactory }) =>
-				new ReadResolver(mapperFactory, queryAstFactory))
-			.addService('validationDependencyCollector', () =>
-				new DependencyCollector())
-			.addService('validationQueryAstFactory', ({ schema }) =>
-				new QueryAstFactory(schema.model))
-			.addService('dataSelector', ({ validationQueryAstFactory, schema }) =>
-				new ValidationDataSelector(schema.model, validationQueryAstFactory))
-			.addService('columnValueResolver', ({ providers }) =>
-				new ColumnValueResolver(providers))
-			.addService('entityRulesResolver', ({ schema }) =>
-				new EntityRulesResolver(schema.validation, schema.model))
-			.addService('inputPreValidator', ({ entityRulesResolver, columnValueResolver, dataSelector, schema }) =>
-				new InputPreValidator(schema.model, entityRulesResolver, columnValueResolver, dataSelector))
-			.addService('mutationResolver', ({ mapperFactory, inputPreValidator, queryAstFactory, schema, schemaDatabaseMetadata }) =>
-				new MutationResolver(schema.model, mapperFactory, inputPreValidator, queryAstFactory, schemaDatabaseMetadata))
-			.addService('validationResolver', ({ inputPreValidator, mapperFactory }) =>
-				new ValidationResolver(mapperFactory, inputPreValidator))
-			.addService('refreshViewResolver', ({ schema, mapperFactory }) =>
-				new RefreshViewResolver(schema, mapperFactory))
+					schema,
+					schemaDatabaseMetadata,
+				}) => {
+					return new MapperFactory(
+						db,
+						identityId,
+						schema.model,
+						schemaDatabaseMetadata,
+						predicatesInjector,
+						selectBuilderFactory,
+						uniqueWhereExpander,
+						whereBuilder,
+						junctionTableManager,
+						deleteExecutor,
+						updater,
+						inserter,
+						pathFactory,
+						providers,
+					)
+				},
+			)
+			.addService('queryAstFactory', () => new GraphQlQueryAstFactory())
+			.addService('readResolver', ({ mapperFactory, queryAstFactory }) => new ReadResolver(mapperFactory, queryAstFactory))
+			.addService('validationDependencyCollector', () => new DependencyCollector())
+			.addService('validationQueryAstFactory', ({ schema }) => new QueryAstFactory(schema.model))
+			.addService('dataSelector', ({ validationQueryAstFactory, schema }) => new ValidationDataSelector(schema.model, validationQueryAstFactory))
+			.addService('columnValueResolver', ({ providers }) => new ColumnValueResolver(providers))
+			.addService('entityRulesResolver', ({ schema }) => new EntityRulesResolver(schema.validation, schema.model))
+			.addService(
+				'inputPreValidator',
+				({ entityRulesResolver, columnValueResolver, dataSelector, schema }) =>
+					new InputPreValidator(schema.model, entityRulesResolver, columnValueResolver, dataSelector),
+			)
+			.addService(
+				'mutationResolver',
+				({ mapperFactory, inputPreValidator, queryAstFactory, schema, schemaDatabaseMetadata }) =>
+					new MutationResolver(schema.model, mapperFactory, inputPreValidator, queryAstFactory, schemaDatabaseMetadata),
+			)
+			.addService('validationResolver', ({ inputPreValidator, mapperFactory }) => new ValidationResolver(mapperFactory, inputPreValidator))
+			.addService('refreshViewResolver', ({ schema, mapperFactory }) => new RefreshViewResolver(schema, mapperFactory))
 	}
 
 	public create(args: ExecutionContainerArgs): ExecutionContainer {
 		return this.createBuilder(args).build().pick('validationResolver', 'readResolver', 'mutationResolver', 'refreshViewResolver')
 	}
 }
-

package/src/acl/Authorizator.ts

@@ -1,6 +1,5 @@
 import { Acl } from '@contember/schema'
 
-
 export type AuthorizationResult = 'yes' | 'no' | 'maybe'
 
 export class Authorizator {
@@ -31,7 +30,11 @@ export class Authorizator {
 		return this.permissions[entity]?.operations[operation]?.[field] ?? false
 	}
 
-	getFieldPermissions(operation: Acl.Operation.create | Acl.Operation.read | Acl.Operation.update, entity: string, field: string): AuthorizationResult {
+	getFieldPermissions(
+		operation: Acl.Operation.create | Acl.Operation.read | Acl.Operation.update,
+		entity: string,
+		field: string,
+	): AuthorizationResult {
 		const fieldPermissions = this.getFieldPredicate(operation, entity, field)
 		if (!fieldPermissions) {
 			return 'no'
@@ -49,7 +52,6 @@ export class Authorizator {
 		return 'maybe'
 	}
 
-
 	isCustomPrimaryAllowed(entity: string): boolean {
 		return this.permissions?.[entity]?.operations?.customPrimary ?? this.defaultCustomPrimary
 	}

package/src/acl/EvaluatedPredicateReplacer.ts

@@ -14,19 +14,14 @@ export class EvaluatedPredicateReplacer {
 		for (const [key, value] of Object.entries(where)) {
 			if (key === 'not') {
 				result['not'] = this.replace(value as Input.OptionalWhere)
-
 			} else if (key === 'and' || key === 'or') {
 				result[key] = (value as Input.Where[]).map(it => this.replace(it))
-
 			} else if (key === this.relation.name) {
 				result[key] = replaceWhere(value as Input.Where, this.evaluatedPredicate, { [this.sourceEntity.primary]: { always: true } })
-
 			} else {
 				result[key] = value
 			}
-
 		}
 		return result
 	}
-
 }

package/src/acl/PermissionFactory.ts

@@ -118,12 +118,13 @@ export class PermissionFactory {
 		}
 		const noRoot: `${Acl.Operation}`[] = []
 
-		for (let operation of [
-			'create',
-			'read',
-			'update',
-		] as const) {
-
+		for (
+			let operation of [
+				'create',
+				'read',
+				'update',
+			] as const
+		) {
 			const { predicates: opPredicates, permissions: fieldPermissions, noRoot: opNoRoot } = this.mergeOperationPermissions(left, right, operation)
 
 			if (opNoRoot) {
@@ -147,7 +148,6 @@ export class PermissionFactory {
 			operations.delete = predicate
 		}
 
-
 		if (noRoot.length > 0) {
 			operations.noRoot = noRoot
 		}
@@ -158,7 +158,6 @@ export class PermissionFactory {
 		}
 	}
 
-
 	private mergeOperationPermissions(left: Acl.EntityPermissions, right: Acl.EntityPermissions, operation: 'create' | 'read' | 'update'): {
 		noRoot: boolean
 		predicates: Acl.PredicateMap
@@ -194,7 +193,7 @@ export class PermissionFactory {
 		}
 	}
 
-	private resolveNoRoot<const Op extends`${Acl.Operation}`>(left: Acl.EntityPermissions, right: Acl.EntityPermissions, operation: Op): {
+	private resolveNoRoot<const Op extends `${Acl.Operation}`>(left: Acl.EntityPermissions, right: Acl.EntityPermissions, operation: Op): {
 		noRoot: boolean
 		leftPermissions: Acl.EntityPermissions['operations'][Op] | undefined
 		rightPermissions: Acl.EntityPermissions['operations'][Op] | undefined
@@ -223,7 +222,7 @@ export class PermissionFactory {
 		leftFieldPermissions: Acl.FieldPermissions | undefined = {},
 		rightPredicates: Acl.PredicateMap,
 		rightFieldPermissions: Acl.FieldPermissions | undefined = {},
-	): {predicates: Acl.PredicateMap; permissions: Acl.FieldPermissions} {
+	): { predicates: Acl.PredicateMap; permissions: Acl.FieldPermissions } {
 		const permissions: Writable<Acl.FieldPermissions> = {}
 		const predicates: Writable<Acl.PredicateMap> = {}
 

package/src/acl/PredicateFactory.ts

@@ -106,7 +106,6 @@ export class PredicateFactory {
 		}
 		const where: Input.Where = predicatesWhere.length === 1 ? predicatesWhere[0] : { and: predicatesWhere }
 		return this.optimizePredicates(where, relationContext)
-
 	}
 
 	private getRequiredPredicates(