@contember/engine-content-api 1.2.0-alpha.17 → 1.2.0-alpha.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-alpha.17",
+  "version": "1.2.0-alpha.19",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,20 +10,21 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.0-alpha.17",
-    "@contember/dic": "^1.2.0-alpha.17",
-    "@contember/engine-common": "^1.2.0-alpha.17",
-    "@contember/logger": "^1.2.0-alpha.17",
-    "@contember/graphql-utils": "^1.2.0-alpha.17",
-    "@contember/schema": "^1.2.0-alpha.17",
-    "@contember/schema-utils": "^1.2.0-alpha.17",
+    "@contember/database": "^1.2.0-alpha.19",
+    "@contember/dic": "^1.2.0-alpha.19",
+    "@contember/logger": "^1.2.0-alpha.19",
+    "@contember/graphql-utils": "^1.2.0-alpha.19",
+    "@contember/schema": "^1.2.0-alpha.19",
+    "@contember/schema-definition": "^1.2.0-alpha.19",
+    "@contember/schema-utils": "^1.2.0-alpha.19",
     "@graphql-tools/schema": "^8.3.5",
+    "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-alpha.17",
-    "@contember/engine-api-tester": "^1.2.0-alpha.17",
-    "@contember/schema-definition": "^1.2.0-alpha.17",
+    "@contember/database-tester": "^1.2.0-alpha.19",
+    "@contember/engine-api-tester": "^1.2.0-alpha.19",
+    "@contember/schema-definition": "^1.2.0-alpha.19",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/mapper/MapperContainer.ts

@@ -65,7 +65,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 		.addService('whereOptimized', () =>
 			new WhereOptimizer(schema.model, new ConditionOptimizer()))
 		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized }) =>
-			new WhereBuilder(schema.model, 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 }) =>

package/src/mapper/delete/DeleteExecutor.ts

@@ -36,7 +36,6 @@ export class DeleteExecutor {
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		return mapper.mutex.execute(async () => {
-			await mapper.constraintHelper.setFkConstraintsDeferred()
 			const primaryValue = await mapper.getPrimaryValue(entity, by)
 			if (!primaryValue) {
 				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
@@ -44,13 +43,14 @@ export class DeleteExecutor {
 			if (mapper.deletedEntities.isDeleted(entity.name, primaryValue)) {
 				return [new MutationNothingToDo([], NothingToDoReason.alreadyDeleted)]
 			}
+			await mapper.constraintHelper.setFkConstraintsDeferred()
 			const primaryWhere = { [entity.primary]: { eq: primaryValue } }
 			const result = await this.delete(mapper, entity, filter ? { and: [primaryWhere, filter] } : primaryWhere)
+			await mapper.constraintHelper.setFkConstraintsImmediate()
 			if (result.length === 0) {
 				return [new MutationNoResultError([])]
 			}
 
-			await mapper.constraintHelper.setFkConstraintsImmediate()
 			return [new MutationDeleteOk([], entity, primaryValue)]
 		})
 	}

package/src/mapper/select/Path.ts

@@ -27,6 +27,9 @@ export class PathFactory {
 export class Path {
 	public readonly alias = this.createAlias()
 
+	public get fullAlias() {
+		return this.rootAlias + this.path.join('_')
+	}
 	constructor(
 		public readonly path: string[],
 		private readonly aliasContext: AliasContext,
@@ -44,7 +47,7 @@ export class Path {
 	}
 
 	private createAlias(): string {
-		const alias = this.rootAlias + this.path.join('_')
+		const alias = this.fullAlias
 
 		// intentionally not allowing == MAX_IDENTIFIER_LENGTH
 		if (alias.length < MAX_IDENTIFIER_LENGTH) {

package/src/mapper/select/WhereBuilder.ts

@@ -20,6 +20,7 @@ export class WhereBuilder {
 		private readonly conditionBuilder: ConditionBuilder,
 		private readonly pathFactory: PathFactory,
 		private readonly whereOptimizer: WhereOptimizer,
+		private readonly useExistsInHasManyFilter: boolean,
 	) {}
 
 	public build(
@@ -30,7 +31,13 @@ export class WhereBuilder {
 		optimizationHints: WhereOptimizationHints = {},
 	) {
 		const optimizedWhere = this.whereOptimizer.optimize(where, entity, optimizationHints)
-		return this.buildInternal(entity, path, optimizedWhere, cb => qb.where(clause => cb(clause)), false)
+		return this.buildInternal({
+			entity,
+			path,
+			where: optimizedWhere,
+			callback: cb => qb.where(clause => cb(clause)),
+			allowManyJoin: false,
+		})
 	}
 
 
@@ -42,32 +49,41 @@ export class WhereBuilder {
 		optimizationHints: WhereOptimizationHints = {},
 	) {
 		const optimizedWhere = this.whereOptimizer.optimize(where, entity, optimizationHints)
-		return this.buildInternal(entity, path, optimizedWhere, callback, false)
+		return this.buildInternal({
+			entity,
+			path,
+			where: optimizedWhere,
+			callback,
+			allowManyJoin: false,
+		})
 	}
 
-	private buildInternal(
-		entity: Model.Entity,
-		path: Path,
-		where: Input.OptionalWhere,
-		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
-		allowManyJoin: boolean,
+	private buildInternal({
+		callback,
+		...args
+	}: { entity: Model.Entity; path: Path; where: Input.OptionalWhere; callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>; allowManyJoin: boolean },
 	) {
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildRecursive(clause, entity, path, where, allowManyJoin, joinList))
+		const qbWithWhere = callback(clause => this.buildRecursive({
+			conditionBuilder: clause,
+			joinList: joinList,
+			...args,
+		}))
 		return joinList.reduce<SelectBuilder<SelectBuilder.Result>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join(qb, path, entity, relationName),
 			qbWithWhere,
 		)
 	}
 
-	private buildRecursive(
-		conditionBuilder: SqlConditionBuilder,
-		entity: Model.Entity,
-		path: Path,
-		where: Input.OptionalWhere,
-		allowManyJoin: boolean,
-		joinList: WhereJoinDefinition[],
+	private buildRecursive({
+		conditionBuilder,
+		entity,
+		path,
+		where,
+		joinList,
+		allowManyJoin,
+	}: { conditionBuilder: SqlConditionBuilder; entity: Model.Entity; path: Path; where: Input.OptionalWhere; joinList: WhereJoinDefinition[]; allowManyJoin: boolean },
 	): SqlConditionBuilder {
 		const tableName = path.alias
 
@@ -76,7 +92,14 @@ export class WhereBuilder {
 			conditionBuilder = conditionBuilder.and(clause =>
 				expr.reduce(
 					(clause2, where) =>
-						!where ? clause2 : this.buildRecursive(clause2, entity, path, where, allowManyJoin, joinList),
+						!where ? clause2 : this.buildRecursive({
+							conditionBuilder: clause2,
+							entity,
+							path,
+							where,
+							joinList,
+							allowManyJoin,
+						}),
 					clause,
 				),
 			)
@@ -88,7 +111,14 @@ export class WhereBuilder {
 					(clause2, where) =>
 						!where
 							? clause2
-							: clause2.and(clause3 => this.buildRecursive(clause3, entity, path, where, allowManyJoin, joinList)),
+							: clause2.and(clause3 => this.buildRecursive({
+								conditionBuilder: clause3,
+								entity,
+								path,
+								where,
+								joinList,
+								allowManyJoin,
+							})),
 					clause,
 				),
 			)
@@ -96,7 +126,14 @@ export class WhereBuilder {
 		if (where.not !== undefined) {
 			const expr = where.not
 			conditionBuilder = conditionBuilder.not(clause =>
-				this.buildRecursive(clause, entity, path, expr, allowManyJoin, joinList),
+				this.buildRecursive({
+					conditionBuilder: clause,
+					entity,
+					path,
+					where: expr,
+					joinList,
+					allowManyJoin,
+				}),
 			)
 		}
 
@@ -105,8 +142,9 @@ export class WhereBuilder {
 				continue
 			}
 
+			const targetPath = path.for(fieldName)
+
 			const joinedWhere = ({ targetEntity, relation, entity }: Model.AnyRelationContext): SqlConditionBuilder => {
-				const targetPath = path.for(fieldName)
 				const relationWhere = where[fieldName] as Input.Where
 				if (Object.keys(relationWhere).length === 0) {
 					return conditionBuilder
@@ -126,7 +164,14 @@ export class WhereBuilder {
 
 				joinList.push({ path: targetPath, entity, relationName: relation.name })
 
-				return this.buildRecursive(conditionBuilder, targetEntity, targetPath, relationWhere, allowManyJoin, joinList)
+				return this.buildRecursive({
+					conditionBuilder,
+					entity: targetEntity,
+					path: targetPath,
+					where: relationWhere,
+					joinList,
+					allowManyJoin,
+				})
 			}
 
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
@@ -138,7 +183,7 @@ export class WhereBuilder {
 				visitOneHasOneOwning: joinedWhere,
 				visitManyHasOne: joinedWhere,
 				visitManyHasManyInverse: context => {
-					if (allowManyJoin) {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
 						return joinedWhere(context)
 					}
 
@@ -151,11 +196,12 @@ export class WhereBuilder {
 							context.targetEntity,
 							context.targetRelation.joiningTable,
 							'inverse',
+							targetPath,
 						),
 					)
 				},
 				visitManyHasManyOwning: context => {
-					if (allowManyJoin) {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
 						return joinedWhere(context)
 					}
 
@@ -168,11 +214,12 @@ export class WhereBuilder {
 							context.targetEntity,
 							context.relation.joiningTable,
 							'owning',
+							targetPath,
 						),
 					)
 				},
 				visitOneHasMany: context => {
-					if (allowManyJoin) {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
 						return joinedWhere(context)
 					}
 
@@ -181,23 +228,23 @@ export class WhereBuilder {
 					const qb = this.hasRootIsNull(relationWhere, context.targetEntity)
 						? SelectBuilder.create()
 							.select(it => it.raw('1'))
-							.from(new Literal(`(select ${wrapIdentifier(tableName)}.${wrapIdentifier(entity.primaryColumn)})`), 'sub2_')
-							.leftJoin(context.targetEntity.tableName, 'sub_', it =>
-								it.columnsEq(['sub2_', entity.primaryColumn], ['sub_', context.targetRelation.joiningColumn.columnName]),
+							.from(new Literal(`(select ${wrapIdentifier(tableName)}.${wrapIdentifier(entity.primaryColumn)})`), targetPath.for('tmp_').alias)
+							.leftJoin(context.targetEntity.tableName, targetPath.alias, it =>
+								it.columnsEq([targetPath.for('tmp_').alias, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]),
 							)
 						: SelectBuilder.create()
 							.select(it => it.raw('1'))
-							.from(context.targetEntity.tableName, 'sub_')
-							.where(it => it.columnsEq([tableName, entity.primaryColumn], ['sub_', context.targetRelation.joiningColumn.columnName]))
+							.from(context.targetEntity.tableName, targetPath.alias)
+							.where(it => it.columnsEq([tableName, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]))
 
 					return conditionBuilder.exists(
-						this.buildInternal(
-							context.targetEntity,
-							this.pathFactory.create([], 'sub_'),
-							relationWhere,
-							cb => qb.where(clause => cb(clause)),
-							true,
-						),
+						this.buildInternal({
+							entity: context.targetEntity,
+							path: targetPath,
+							where: relationWhere,
+							callback: cb => qb.where(clause => cb(clause)),
+							allowManyJoin: true,
+						}),
 					)
 				},
 			})
@@ -212,13 +259,15 @@ export class WhereBuilder {
 		targetEntity: Model.Entity,
 		joiningTable: Model.JoiningTable,
 		fromSide: 'owning' | 'inverse',
+		path: Path,
 	) {
 		const fromColumn = fromSide === 'owning' ? joiningTable.joiningColumn.columnName : joiningTable.inverseJoiningColumn.columnName
 		const toColumn = fromSide === 'owning' ? joiningTable.inverseJoiningColumn.columnName : joiningTable.joiningColumn.columnName
+		const junctionPath = path.for('junction_')
 		const qb = SelectBuilder.create<SelectBuilder.Result>()
-			.from(joiningTable.tableName, 'junction_')
+			.from(joiningTable.tableName, junctionPath.alias)
 			.select(it => it.raw('1'))
-			.where(it => it.columnsEq(outerColumn, ['junction_', fromColumn]))
+			.where(it => it.columnsEq(outerColumn, [junctionPath.alias, fromColumn]))
 
 		const primaryCondition = this.transformWhereToPrimaryCondition(relationWhere, targetEntity.primary)
 		if (primaryCondition !== null) {
@@ -226,20 +275,20 @@ export class WhereBuilder {
 			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType
 
 			return qb.where(condition =>
-				this.conditionBuilder.build(condition, 'junction_', toColumn, columnType, primaryCondition),
+				this.conditionBuilder.build(condition, junctionPath.alias, toColumn, columnType, primaryCondition),
 			)
 		}
 
-		const qbJoined = qb.join(targetEntity.tableName, 'sub_', clause =>
-			clause.compareColumns(['junction_', toColumn], Operator.eq, ['sub_', targetEntity.primary]),
-		)
-		return this.buildInternal(
-			targetEntity,
-			this.pathFactory.create([], 'sub_'),
-			relationWhere,
-			cb => qbJoined.where(clause => cb(clause)),
-			true,
+		const qbJoined = qb.join(targetEntity.tableName, path.alias, clause =>
+			clause.compareColumns([junctionPath.alias, toColumn], Operator.eq, [path.alias, targetEntity.primary]),
 		)
+		return this.buildInternal({
+			entity: targetEntity,
+			path: this.pathFactory.create([], path.fullAlias),
+			where: relationWhere,
+			callback: cb => qbJoined.where(clause => cb(clause)),
+			allowManyJoin: true,
+		})
 	}
 
 	private transformWhereToPrimaryCondition(where: Input.Where, primaryField: string): Input.Condition<never> | null {

package/src/resolvers/ExecutionContainerFactory.ts

@@ -15,7 +15,7 @@ import {
 import { ValidationResolver } from './ValidationResolver'
 import { Providers } from '@contember/schema-utils'
 import { GraphQlQueryAstFactory } from './GraphQlQueryAstFactory'
-import { getArgumentValues } from 'graphql/execution/values'
+import { getArgumentValues } from 'graphql'
 import { createMapperContainer } from '../mapper'
 
 export interface ExecutionContainer {

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -2,17 +2,18 @@ import { isIt, ResolveInfoUtils } from '../utils'
 import {
 	FieldNode as GraphQlFieldNode,
 	FragmentSpreadNode,
+	getArgumentValues,
 	GraphQLObjectType,
 	GraphQLOutputType,
 	GraphQLResolveInfo,
 	isListType,
 	isNonNullType,
-	isObjectType, Kind,
+	isObjectType,
+	Kind,
+	SelectionSetNode,
 } from 'graphql'
-import { SelectionSetNode } from 'graphql/language/ast'
-import { getArgumentValues } from 'graphql/execution/values'
 import { FieldNode, ObjectNode } from '../inputProcessing'
-import { isDeepStrictEqual } from 'util'
+import { isDeepStrictEqual } from 'node:util'
 
 type NodeFilter = (node: GraphQlFieldNode, path: string[]) => boolean
 type AnyNode = ObjectNode | FieldNode

package/src/resolvers/MutationResolver.ts

@@ -62,6 +62,7 @@ export class MutationResolver {
 
 		return this.transaction(async (mapper, trx) => {
 			if (options?.deferForeignKeyConstraints) {
+				logger.debug('MutationResolver: deferring foreign constraints')
 				await mapper.constraintHelper.setFkConstraintsDeferred()
 			}
 			const validationResult: Record<string, Result.MutationFieldResult> = {}
@@ -145,7 +146,7 @@ export class MutationResolver {
 				}
 
 				const meta = readOperationMeta(fieldConfig.extensions)
-
+				logger.debug('MutationResolver: Resolving a field', { field: field.alias })
 				const result: {
 					ok: boolean
 					validation?: Result.ValidationResult
@@ -169,6 +170,7 @@ export class MutationResolver {
 				})()
 
 				if (!result.ok) {
+					logger.debug('MutationResolver: Field evaluation failed', { result, field: field.alias })
 					const validationErrors = result.validation ? prefixErrors(result.validation.errors, field.alias) : []
 					const executionErrors = prefixErrors(result.errors, field.alias)
 					return {
@@ -193,12 +195,14 @@ export class MutationResolver {
 				trxResult[field.alias] = result
 			}
 			if (options?.deferForeignKeyConstraints) {
+				logger.debug('MutationResolver: validating fk constraints')
 				const constraintsResult = await tryMutation(this.schema, async () => {
 					await mapper.constraintHelper.setFkConstraintsImmediate()
 					return []
 				})
 				const errorResponse = this.createErrorResponse(constraintsResult)
 				if (errorResponse) {
+					logger.debug('MutationResolver: deferred fk validation failed', { errorResponse })
 					return { ...errorResponse, ...validationResult }
 				}
 			}
@@ -469,13 +473,17 @@ export class MutationResolver {
 		return await retryTransaction(
 			async () => {
 				return await this.db.transaction(async trx => {
+					logger.debug('MutationResolver: Starting mutation transaction')
 					await trx.connection.query(Connection.REPEATABLE_READ)
 					await this.systemVariablesSetup(trx)
 					const mapper = this.mapperFactory(trx)
 
 					const result = await cb(mapper, trx)
 					if (!result.ok) {
+						logger.debug('MutationResolver: Transaction failed, rolling back', { result })
 						await trx.connection.rollback()
+					} else {
+						logger.debug('MutationResolver: Transaction ok, committing')
 					}
 					return result
 				})

package/src/schema/EnumsProvider.ts

@@ -1,8 +1,6 @@
-import { GraphQLEnumType } from 'graphql'
-import { GraphQLEnumValueConfigMap } from 'graphql/type/definition'
+import { GraphQLEnumType, GraphQLEnumValueConfigMap } from 'graphql'
 import { Model } from '@contember/schema'
-import { singletonFactory } from '../utils'
-import { capitalizeFirstLetter } from '../utils'
+import { capitalizeFirstLetter, singletonFactory } from '../utils'
 
 export class EnumsProvider {
 	private schema: Model.Schema

package/src/schema/OrderByTypeProvider.ts

@@ -1,11 +1,18 @@
-import { GraphQLInputFieldConfig, GraphQLInputFieldConfigMap, GraphQLInputType } from 'graphql/type/definition'
+import {
+	GraphQLBoolean,
+	GraphQLEnumType,
+	GraphQLInputFieldConfig,
+	GraphQLInputFieldConfigMap,
+	GraphQLInputObjectType,
+	GraphQLInputType,
+	GraphQLInt,
+} from 'graphql'
 import { Acl, Model } from '@contember/schema'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { singletonFactory } from '../utils'
 import { GqlTypeName } from './utils'
 import { Authorizator } from '../acl'
 import { FieldAccessVisitor } from './FieldAccessVisitor'
-import { GraphQLBoolean, GraphQLEnumType, GraphQLInputObjectType, GraphQLInt } from 'graphql'
 
 export class OrderByTypeProvider {
 	private orderBySingleton = singletonFactory(name => this.createEntityOrderByType(name))

package/src/schema/WhereTypeProvider.ts

@@ -1,7 +1,6 @@
 import { Acl, Model } from '@contember/schema'
 import { acceptFieldVisitor, getEntity } from '@contember/schema-utils'
-import { GraphQLInputObjectType, GraphQLList } from 'graphql'
-import { GraphQLInputFieldConfig, GraphQLInputFieldConfigMap } from 'graphql/type/definition'
+import { GraphQLInputFieldConfig, GraphQLInputFieldConfigMap, GraphQLInputObjectType, GraphQLList } from 'graphql'
 import { capitalizeFirstLetter, getFieldsForUniqueWhere, singletonFactory } from '../utils'
 import { ColumnTypeResolver } from './ColumnTypeResolver'
 import { ConditionTypeProvider } from './ConditionTypeProvider'

package/src/schema/entities/FieldArgsVisitor.ts

@@ -1,8 +1,7 @@
 import { Model } from '@contember/schema'
 import { WhereTypeProvider } from '../WhereTypeProvider'
-import { GraphQLFieldConfigArgumentMap } from 'graphql/type/definition'
+import { GraphQLFieldConfigArgumentMap, GraphQLInt, GraphQLList, GraphQLNonNull } from 'graphql'
 import { OrderByTypeProvider } from '../OrderByTypeProvider'
-import { GraphQLInt, GraphQLList, GraphQLNonNull } from 'graphql'
 
 export class FieldArgsVisitor implements
 	Model.ColumnVisitor<GraphQLFieldConfigArgumentMap | undefined>,

package/src/schema/mutations/CreateEntityRelationInputFieldVisitor.ts

@@ -1,10 +1,9 @@
-import { GraphQLInputObjectType, GraphQLString } from 'graphql'
+import { GraphQLInputFieldConfigMap, GraphQLInputObjectType, GraphQLString } from 'graphql'
 import { Input, Model } from '@contember/schema'
 import { GqlTypeName } from '../utils'
 import { WhereTypeProvider } from '../WhereTypeProvider'
 import { Accessor, Interface } from '../../utils'
 import { EntityInputProvider, EntityInputType } from './EntityInputProvider'
-import { GraphQLInputFieldConfigMap } from 'graphql/type/definition'
 import { CreateEntityRelationAllowedOperationsVisitor } from './CreateEntityRelationAllowedOperationsVisitor'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { ImplementationException } from '../../exception'

package/src/schema/mutations/UpdateEntityRelationInputFieldVisitor.ts

@@ -1,10 +1,15 @@
-import { GraphQLBoolean, GraphQLInputObjectType, GraphQLString } from 'graphql'
+import {
+	GraphQLBoolean,
+	GraphQLInputFieldConfig,
+	GraphQLInputFieldConfigMap,
+	GraphQLInputObjectType,
+	GraphQLString,
+} from 'graphql'
 import { Acl, Input, Model } from '@contember/schema'
 import { GqlTypeName } from '../utils'
 import { WhereTypeProvider } from '../WhereTypeProvider'
 import { Accessor, filterObject } from '../../utils'
 import { EntityInputProvider, EntityInputType } from './EntityInputProvider'
-import { GraphQLInputFieldConfig, GraphQLInputFieldConfigMap } from 'graphql/type/definition'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { UpdateEntityRelationAllowedOperationsVisitor } from './UpdateEntityRelationAllowedOperationsVisitor'
 import { Authorizator } from '../../acl'

package/src/schema/utils.ts

@@ -1,5 +1,5 @@
 import { capitalizeFirstLetter } from '../utils'
-import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { GraphQLFieldResolver } from 'graphql'
 
 export const GqlTypeName = (strings: TemplateStringsArray, ...values: string[]) => {
 	return strings.reduce((combined, string, i) => {

package/src/tsconfig.json

@@ -11,9 +11,6 @@
 		{
 			"path": "../../dic/src"
 		},
-		{
-			"path": "../../engine-common/src"
-		},
 		{
 			"path": "../../graphql-utils/src"
 		},

package/tests/cases/bugs/bug102.test.ts

@@ -48,12 +48,12 @@ test('Filter by has many with additional join', async () => {
 		executes: [
 			{
 				sql: SQL`
-select "root_"."id" as "root_id", "root_"."short_name" as "root_shortName", "root_"."id" as "root_id"
-from "public"."person" as "root_"
-where exists (select 1
-  from "public"."person_locale" as "sub_"
-    left join "public"."language" as "sub_locale" on "sub_"."locale_id" = "sub_locale"."id"
-  where "root_"."id" = "sub_"."person_id" and "sub_locale"."slug" = ? and not("sub_"."url_slug" is null))`,
+					select "root_"."id" as "root_id", "root_"."short_name" as "root_shortName", "root_"."id" as "root_id"
+					from "public"."person" as "root_"
+					where exists (select 1
+						from "public"."person_locale" as "root_locales"
+						left join  "public"."language" as "root_locales_locale" on  "root_locales"."locale_id" = "root_locales_locale"."id"
+						where "root_"."id" = "root_locales"."person_id" and "root_locales_locale"."slug" = ? and not("root_locales"."url_slug" is null))`,
 				response: { rows: [{ root_id: testUuid(1), root_shortName: 'John' }] },
 				parameters: ['cs'],
 			},

package/tests/cases/integration/graphQlRequests/delete/aclDelete.test.ts

@@ -50,12 +50,12 @@ test('delete post with acl', async () => {
 						],
 					},
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."post"
             where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlRequests/delete/additionalDeleteFilter.test.ts

@@ -34,12 +34,12 @@ test('delete post with additional filter', async () => {
 						],
 					},
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."post"
             where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlRequests/delete/cascadeDelete.test.ts

@@ -39,12 +39,12 @@ test('delete author with posts and locales cascade delete', async () => {
 						],
 					},
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."author" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."author" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."author"
             where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlRequests/delete/deleteById.test.ts

@@ -57,12 +57,12 @@ test('delete post by id', async () => {
 						],
 					},
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."post"
             where "id" in (select "root_"."id"