@contember/engine-content-api 1.1.1 → 1.2.0-alpha.10

package/src/mapper/select/WhereBuilder.ts

@@ -5,6 +5,7 @@ import { Path, PathFactory } from './Path'
 import { JoinBuilder } from './JoinBuilder'
 import { ConditionBuilder } from './ConditionBuilder'
 import { ConditionBuilder as SqlConditionBuilder, Operator, QueryBuilder, SelectBuilder } from '@contember/database'
+import { WhereOptimizer } from './optimizer/WhereOptimizer'
 
 export class WhereBuilder {
 	constructor(
@@ -12,6 +13,7 @@ export class WhereBuilder {
 		private readonly joinBuilder: JoinBuilder,
 		private readonly conditionBuilder: ConditionBuilder,
 		private readonly pathFactory: PathFactory,
+		private readonly whereOptimizer: WhereOptimizer,
 	) {}
 
 	public build(
@@ -31,9 +33,10 @@ export class WhereBuilder {
 		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
 		allowManyJoin: boolean = false,
 	) {
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity)
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildInternal(clause, entity, path, where, allowManyJoin, joinList))
+		const qbWithWhere = callback(clause => this.buildInternal(clause, entity, path, optimizedWhere, allowManyJoin, joinList))
 		return joinList.reduce<SelectBuilder<SelectBuilder.Result>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join(qb, path, entity, relationName),
 			qbWithWhere,
@@ -44,7 +47,7 @@ export class WhereBuilder {
 		conditionBuilder: SqlConditionBuilder,
 		entity: Model.Entity,
 		path: Path,
-		where: Input.OptionalWhere,
+		where: Input.Where,
 		allowManyJoin: boolean,
 		joinList: WhereJoinDefinition[],
 	): SqlConditionBuilder {

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -4,7 +4,6 @@ import { RelationFetcher } from '../RelationFetcher'
 import { SelectExecutionHandlerContext } from '../SelectExecutionHandler'
 import { PredicateFactory } from '../../../acl'
 import { WhereBuilder } from '../WhereBuilder'
-import { JoiningColumns } from '../../types'
 
 export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.ColumnVisitor<void> {
 	constructor(
@@ -56,11 +55,6 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyOwningRelation,
 	): void {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.inverseJoiningColumn,
-			targetColumn: joiningTable.joiningColumn,
-		}
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
@@ -69,13 +63,15 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 			entity.primary,
 			async ids =>
 				this.relationFetcher.fetchManyHasManyGroups(
-					this.mapper,
-					field,
-					targetEntity,
-					relation,
-					targetRelation,
-					columns,
-					ids,
+					{
+						mapper: this.mapper,
+						field: field,
+						targetEntity: targetEntity,
+						sourceRelation: relation,
+						targetRelation,
+						directionFrom: 'inverse',
+						ids: ids,
+					},
 				),
 			[],
 		)
@@ -85,12 +81,8 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		entity: Model.Entity,
 		relation: Model.ManyHasManyOwningRelation,
 		targetEntity: Model.Entity,
+		targetRelation: Model.ManyHasManyInverseRelation | null,
 	): void {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
@@ -99,7 +91,15 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		this.executionContext.addData(
 			entity.primary,
 			async ids =>
-				this.relationFetcher.fetchManyHasManyGroups(this.mapper, field, targetEntity, relation, relation, columns, ids),
+				this.relationFetcher.fetchManyHasManyGroups({
+					mapper: this.mapper,
+					field: field,
+					targetEntity: targetEntity,
+					sourceRelation: relation,
+					targetRelation,
+					directionFrom: 'owning',
+					ids: ids,
+				}),
 			[],
 		)
 	}
@@ -118,7 +118,14 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		this.executionContext.addData(
 			entity.primary,
 			async ids =>
-				this.relationFetcher.fetchOneHasManyGroups(this.mapper, field, targetEntity, relation, targetRelation, ids),
+				this.relationFetcher.fetchOneHasManyGroups({
+					mapper: this.mapper,
+					objectNode: field,
+					targetEntity: targetEntity,
+					relation: relation,
+					targetRelation: targetRelation,
+					ids: ids,
+				}),
 			[],
 		)
 	}
@@ -148,7 +155,7 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = field.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation.name)
+				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetRelation.name)
 			},
 			null,
 		)
@@ -177,13 +184,13 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetEntity.primary)
+				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetEntity.primary)
 			},
 			null,
 		)
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity): void {
+	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity, targetRelation: Model.OneHasManyRelation | null): void {
 		this.executionContext.addData(
 			relation.name,
 			async ids => {
@@ -201,7 +208,7 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetEntity.primary)
+				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetEntity.primary)
 			},
 			null,
 		)

package/src/mapper/select/optimizer/ConditionOptimizer.ts

@@ -0,0 +1,35 @@
+import { Input } from '@contember/schema'
+import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
+
+type ObjectEntry<T> = { [K in keyof Required<T>]: [K, T[K]] }[keyof T]
+
+export class ConditionOptimizer {
+	public optimize(condition: Input.Condition): Omit<Input.Condition, 'always' | 'never'> | boolean {
+		if (condition.never) {
+			return false
+		}
+
+		return optimizeAnd(
+			(Object.entries(condition) as ObjectEntry<typeof condition>[]).map(([key, value]) => {
+				if (value === undefined || value === null) {
+					return undefined
+
+				} else if (key === 'always') {
+					return true
+
+				} else if (key === 'and') {
+					return optimizeAnd(value.map(it => this.optimize(it)))
+
+				} else if (key === 'or') {
+					return optimizeOr(value.map(it => this.optimize(it)))
+
+				} else if (key === 'not') {
+					return optimizeNot(this.optimize(value))
+
+				} else {
+					return { [key]: value }
+				}
+			}),
+		)
+	}
+}

package/src/mapper/select/optimizer/WhereOptimizer.ts

@@ -0,0 +1,100 @@
+import { Input, Model } from '@contember/schema'
+import { ConditionOptimizer } from './ConditionOptimizer'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
+import { replaceWhere } from './WhereReplacer'
+
+export class WhereOptimizer {
+	constructor(
+		private readonly model: Model.Schema,
+		private readonly conditionOptimizer: ConditionOptimizer,
+	) {
+	}
+
+	public optimize(where: Input.OptionalWhere, entity: Model.Entity): Input.Where {
+		const result = this.optimizeWhere(where, entity)
+
+		if (typeof result === 'boolean') {
+			return { [entity.primary]: { [result ? 'always' : 'never']: true } }
+		}
+
+		return result
+	}
+
+	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity): Input.Where | boolean {
+		return this.optimizeAnd(
+			Object.entries(where).map(([key, value]) => {
+				if (value === undefined || value === null) {
+					return undefined
+
+				} else if (key === 'and') {
+					return this.optimizeAnd((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity)), entity)
+
+				} else if (key === 'or') {
+					return this.optimizeOr((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity)), entity)
+
+				} else if (key === 'not') {
+					return optimizeNot(this.optimizeWhere(value as Input.Where, entity))
+
+				} else {
+					return this.resolveFieldValue(entity, key, value)
+				}
+			}),
+			entity,
+		)
+	}
+
+	private optimizeOr(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity): Input.Where | boolean {
+		const optimized = optimizeOr(operands)
+		if (typeof optimized === 'boolean' || !Array.isArray(optimized.or)) {
+			return optimized
+		}
+		const result = this.crossOptimize(optimized.or, entity, { never: true })
+		return optimizeOr(result.map(it => this.optimizeWhere(it, entity)))
+	}
+
+	private optimizeAnd(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity): Input.Where | boolean {
+		const optimized = optimizeAnd(operands)
+		if (typeof optimized === 'boolean' || !Array.isArray(optimized.and)) {
+			return optimized
+		}
+		const result = this.crossOptimize(optimized.and, entity, { always: true })
+		return optimizeAnd(result.map(it => this.optimizeWhere(it, entity)))
+	}
+
+	private crossOptimize(operands: Input.Where[], entity: Model.Entity, replacement: Input.Condition): Input.Where[] {
+		const result = [...operands]
+		const count = result.length
+		for (let i = 0; i < count; i++) {
+			for (let j = 0; j < count; j++) {
+				if (i !== j) {
+					result[j] = replaceWhere(result[j], result[i], { [entity.primary]: replacement })
+				}
+			}
+		}
+		return result
+	}
+
+	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string]) {
+		return acceptFieldVisitor<Input.Where | boolean>(this.model, entity, key, {
+			visitColumn: () => {
+				const optimizedCondition = this.conditionOptimizer.optimize(value as Input.Condition)
+
+				if (typeof optimizedCondition === 'boolean') {
+					return optimizedCondition
+				}
+
+				return { [key]: optimizedCondition }
+			},
+			visitRelation: (entity, relation, targetEntity) => {
+				const optimizedWhere = this.optimizeWhere(value as Input.Where, targetEntity)
+
+				if (typeof optimizedWhere === 'boolean') {
+					return optimizedWhere
+				}
+
+				return { [key]: optimizedWhere }
+			},
+		})
+	}
+}

package/src/mapper/select/optimizer/WhereReplacer.ts

@@ -0,0 +1,22 @@
+import { Input, Writable } from '@contember/schema'
+import deepEqual from 'fast-deep-equal'
+
+export const replaceWhere = (subject: Input.Where, find: Input.Where, replace: Input.Where): Input.Where => {
+	if (deepEqual(subject, find)) {
+		return replace
+	}
+	const result: Writable<Input.Where> = {}
+	for (const [key, value] of Object.entries(subject)) {
+		if (key === 'not') {
+			result['not'] = replaceWhere(value as Input.Where, find, replace)
+
+		} else if (key === 'and' || key === 'or') {
+			result[key] = (value as Input.Where[]).map(it => replaceWhere(it, find, replace))
+
+		} else {
+			result[key] = value
+		}
+
+	}
+	return result
+}

package/src/mapper/select/optimizer/helpers.ts

@@ -0,0 +1,58 @@
+export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly (P | boolean | undefined)[]): P | { or?: P[] } | boolean => {
+	const normalized: P[] = []
+	let hasNever = false
+	for (const operand of operands) {
+		if (operand === true) {
+			return true
+		} else if (operand === false) {
+			hasNever = true
+		} else if (operand !== undefined)  {
+			normalized.push(...Array.isArray(operand.or) ? operand.or : [operand])
+		}
+	}
+
+	if (normalized.length > 1) {
+		return { or: normalized }
+	} else if (normalized.length === 1) {
+		return normalized[0]
+	} else if (hasNever) {
+		return false
+	} else {
+		return {}
+	}
+}
+
+export const optimizeAnd = <P extends Record<string, unknown>>(operands: readonly (P | boolean | undefined)[]): P | { and?: P[] } | boolean => {
+	const normalized: P[] = []
+	let hasAlways = false
+
+	for (const operand of operands) {
+		if (operand === true) {
+			hasAlways = true
+		} else if (operand === false) {
+			return false
+		} else if (operand !== undefined) {
+			normalized.push(...Array.isArray(operand.and) ? operand.and : [operand])
+		}
+	}
+
+	if (normalized.length > 1) {
+		return { and: normalized }
+	} else if (normalized.length === 1) {
+		return normalized[0]
+	} else if (hasAlways) {
+		return true
+	} else {
+		return {}
+	}
+}
+
+export const optimizeNot = <P extends Record<string, unknown>>(operand: P | boolean): P['not'] | { not: P } | boolean => {
+	if (typeof operand === 'boolean') {
+		return !operand
+	} else if (operand.not) {
+		return operand.not as P['not']
+	} else {
+		return { not: operand }
+	}
+}

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -7,7 +7,7 @@ import {
 	GraphQLResolveInfo,
 	isListType,
 	isNonNullType,
-	isObjectType,
+	isObjectType, Kind,
 } from 'graphql'
 import { SelectionSetNode } from 'graphql/language/ast'
 import { getArgumentValues } from 'graphql/execution/values'
@@ -67,13 +67,13 @@ export class GraphQlQueryAstFactory {
 	): AnyNode[] {
 		const fields: ObjectNode | FieldNode[] = []
 		for (const subNode of selectionSet.selections) {
-			if (isIt<GraphQlFieldNode>(subNode, 'kind', 'Field')) {
+			if (isIt<GraphQlFieldNode>(subNode, 'kind', Kind.FIELD)) {
 				const field = this.createFromNode(info, parentType, subNode, path, filter)
 				if (field === null) {
 					continue
 				}
 				fields.push(field)
-			} else if (isIt<FragmentSpreadNode>(subNode, 'kind', 'FragmentSpread')) {
+			} else if (isIt<FragmentSpreadNode>(subNode, 'kind', Kind.FRAGMENT_SPREAD)) {
 				const fragmentDefinition = info.fragments[subNode.name.value]
 				if (!fragmentDefinition) {
 					throw new Error(`GraphQlQueryAstFactory: Fragment definition ${subNode.name.value} not found`)

package/src/resolvers/MutationResolver.ts

@@ -457,7 +457,7 @@ export class MutationResolver {
 				throw new Error('MutationResolver: expected ObjectNode')
 			}
 			const objectWithArgs = singleNodeQuery.withArgs({ by: where })
-			nodes[singleNodeQuery.alias] = await mapper.selectUnique(entity, objectWithArgs)
+			nodes[singleNodeQuery.alias] = await mapper.selectUnique(entity, objectWithArgs, null)
 		}
 		return nodes
 	}

package/src/resolvers/ReadHelpers.ts

@@ -15,7 +15,7 @@ export const paginate = async (
 	const totalCount = paginationHelper.requiresTotalCount
 		? await mapper.count(entity, queryAst.args.filter || {})
 		: undefined
-	const nodes = paginationHelper.nodeField ? await mapper.select(entity, paginationHelper.nodeField) : undefined
+	const nodes = paginationHelper.nodeField ? await mapper.select(entity, paginationHelper.nodeField, null) : undefined
 
 	return paginationHelper.createResponse(totalCount, nodes)
 }
@@ -37,9 +37,9 @@ export const executeReadOperations = async (
 		trxResult[field.alias] = await (() => {
 			switch (meta.operation) {
 				case Operation.get:
-					return mapper.selectUnique(meta.entity, field)
+					return mapper.selectUnique(meta.entity, field, null)
 				case Operation.list:
-					return mapper.select(meta.entity, field)
+					return mapper.select(meta.entity, field, null)
 				case Operation.paginate:
 					return paginate(mapper, meta.entity, field)
 				case Operation.create:

package/src/resolvers/ReadResolver.ts

@@ -33,12 +33,12 @@ export class ReadResolver {
 
 	public async resolveListQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.ListQueryInput> = this.queryAstFactory.create(info)
-		return await this.mapperFactory(this.db).select(entity, queryAst)
+		return await this.mapperFactory(this.db).select(entity, queryAst, null)
 	}
 
 	public async resolveGetQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.UniqueQueryInput> = this.queryAstFactory.create(info)
-		return await this.mapperFactory(this.db).selectUnique(entity, queryAst)
+		return await this.mapperFactory(this.db).selectUnique(entity, queryAst, null)
 	}
 
 	public async resolvePaginationQuery(entity: Model.Entity, info: GraphQLResolveInfo) {

package/src/utils/object.ts

@@ -9,18 +9,18 @@ function filterObject<Input extends {}, Result extends { [Key in keyof Input]: I
 	object: Input,
 	callback: TypeGuard<Input, Result> | Filter<Input>,
 ): Result {
-	return (Object.entries(object) as any)
-		.filter(<K extends keyof Input>(it: [K, Input[K]]): it is [K, Result[K]] =>
-			(callback as any)(it[0] as K, it[1] as Input[K], object),
-		)
-		.reduce((result: Result, [key, value]: [string, any]) => ({ ...(result as any), [key]: value }), {} as Result)
+	return Object.fromEntries(Object.entries(object)
+		.filter(([key, value]) => (callback as any)(key, value, object)),
+	) as Result
 }
 
 function mapObject<Input, Result>(
 	input: { [key: string]: Input },
 	callback: (value: Input, key: string) => Result,
 ): { [key: string]: Result } {
-	return Object.keys(input).reduce((acc, key) => ({ ...acc, [key]: callback(input[key], key) }), {})
+	return Object.fromEntries(
+		Object.entries(input).map(([key, value]) => [key, callback(value, key)]),
+	)
 }
 
 export { filterObject, mapObject }

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

@@ -1,7 +1,7 @@
 import { test } from 'vitest'
 import { execute, sqlDeferred, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Model } from '@contember/schema'
+import { Acl, Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../src/tags'
 import { testUuid } from '../../../../src/testUuid'
 
@@ -32,7 +32,7 @@ test('delete post with acl', async () => {
 			},
 		},
 		variables: {
-			locale_variable: ['cs'],
+			locale_variable: { in: ['cs'] },
 		},
 		executes: [
 			...sqlTransaction([

package/tests/cases/integration/graphQlRequests/insert/acl/setField.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'vitest'
 import { execute, failedTransaction, sqlTransaction } from '../../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Model } from '@contember/schema'
+import { Acl, Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../../src/tags'
 import { testUuid } from '../../../../../src/testUuid'
 
@@ -34,7 +34,7 @@ test('set a name - allowed', async () => {
 			},
 		},
 		variables: {
-			name_variable: ['John', 'Jack'],
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...sqlTransaction([
@@ -89,7 +89,7 @@ test('set a name - denied', async () => {
 			},
 		},
 		variables: {
-			name_variable: ['John', 'Jack'],
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...failedTransaction([

package/tests/cases/integration/graphQlRequests/insert/aclInsert.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'vitest'
 import { execute, sqlTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Model } from '@contember/schema'
+import { Acl, Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../src/tags'
 import { testUuid } from '../../../../src/testUuid'
 
@@ -27,7 +27,7 @@ test('insert author (with acl)', async () => {
 			},
 		},
 		variables: {
-			name_variable: ['John', 'Jack'],
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		query: GQL`
         mutation {

package/tests/cases/integration/graphQlRequests/query/acl/fieldRestrictedByLocale.test.ts

@@ -7,7 +7,7 @@ import { testUuid } from '../../../../../src/testUuid'
 
 const schema = new SchemaBuilder()
 	.enum('locale', ['cs', 'en'])
-	.entity('Post', entityBuilder => entityBuilder.oneHasMany('locales', c => c.target('PostLocale')))
+	.entity('Post', entityBuilder => entityBuilder.oneHasMany('locales', c => c.target('PostLocale').ownedBy('post')))
 	.entity('PostLocale', entity =>
 		entity
 			.column('title', column => column.type(Model.ColumnType.String))
@@ -34,6 +34,7 @@ const permissions: Acl.Permissions = {
 		operations: {
 			read: {
 				id: true,
+				post: true,
 				title: 'localePredicate',
 			},
 		},
@@ -45,7 +46,7 @@ test('querying id and title', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			localeVariable: ['cs'],
+			localeVariable: { in: ['cs'] },
 		},
 		query: GQL`
         query {
@@ -121,7 +122,7 @@ test('querying with extra where', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			localeVariable: ['cs'],
+			localeVariable: { in: ['cs'] },
 		},
 		query: GQL`
         query {
@@ -167,7 +168,7 @@ test('querying only id', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			localeVariable: ['cs'],
+			localeVariable: { in: ['cs'] },
 		},
 		query: GQL`
         query {
@@ -239,7 +240,7 @@ test('querying on nested field', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			localeVariable: ['cs'],
+			localeVariable: { in: ['cs'] },
 		},
 		query: GQL`
         query {
@@ -274,7 +275,7 @@ test('querying on nested field', async () => {
                          "root_"."id" as "root_id",
                          case when "root_"."locale" in (?) then "root_"."title" else null end as "root_title"
                        from "public"."post_locale" as "root_"
-                       where "root_"."post_id" in (?, ?) and false`,
+                       where "root_"."post_id" in (?, ?)`,
 				parameters: ['cs', testUuid(1), testUuid(2)],
 				response: {
 					rows: [

package/tests/cases/integration/graphQlRequests/query/acl/nestedPredicate.test.ts

@@ -58,7 +58,7 @@ test('querying post + author name', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			countryVariable: ['Czechia'],
+			countryVariable: { in: ['Czechia'] },
 		},
 		query: GQL`
         query {