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

package/src/mapper/types.ts

@@ -1,10 +1,9 @@
-import { Model, Input, Value } from '@contember/schema'
+import { Input, Model, Value } from '@contember/schema'
 import { CheckedPrimary } from './CheckedPrimary'
 
 export type JoiningColumns = { sourceColumn: Model.JoiningColumn; targetColumn: Model.JoiningColumn }
 
 export namespace MapperInput {
-
 	export interface ConnectRelationInput {
 		connect: Input.UniqueWhere | CheckedPrimary
 	}
@@ -58,11 +57,13 @@ export namespace MapperInput {
 		[column: string]: Value.FieldValue | CreateOneRelationInput | CreateManyRelationInput
 	}
 
-	export type CreateOneRelationInput = { alias?: string } & (
-		| ConnectRelationInput
-		| CreateRelationInput
-		| ConnectOrCreateRelationInput
-	)
+	export type CreateOneRelationInput =
+		& { alias?: string }
+		& (
+			| ConnectRelationInput
+			| CreateRelationInput
+			| ConnectOrCreateRelationInput
+		)
 
 	export type CreateManyRelationInput = Array<CreateOneRelationInput>
 
@@ -92,7 +93,6 @@ export namespace MapperInput {
 		filter?: Input.OptionalWhere
 	}
 
-
 	export type UpdateOneRelationInput =
 		| CreateRelationInput
 		| ConnectRelationInput
@@ -102,16 +102,17 @@ export namespace MapperInput {
 		| UpdateRelationInput
 		| UpsertRelationInput
 
-	export type UpdateManyRelationInputItem = { alias?: string } & (
-		| CreateRelationInput
-		| ConnectRelationInput
-		| ConnectOrCreateRelationInput
-		| DeleteSpecifiedRelationInput
-		| DisconnectSpecifiedRelationInput
-		| UpdateSpecifiedRelationInput
-		| UpsertSpecifiedRelationInput
-	)
+	export type UpdateManyRelationInputItem =
+		& { alias?: string }
+		& (
+			| CreateRelationInput
+			| ConnectRelationInput
+			| ConnectOrCreateRelationInput
+			| DeleteSpecifiedRelationInput
+			| DisconnectSpecifiedRelationInput
+			| UpdateSpecifiedRelationInput
+			| UpsertSpecifiedRelationInput
+		)
 
 	export type UpdateManyRelationInput = Array<UpdateManyRelationInputItem>
-
 }

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -11,7 +11,7 @@ import { MutationResultList } from '../Result'
 import { ManyHasOneUpdateInputProcessor } from './relations/ManyHasOneUpdateInputProcessor'
 import { MapperInput } from '../types'
 
-export type SqlUpdateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue}) => Promise<MutationResultList>)
+export type SqlUpdateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue }) => Promise<MutationResultList>)
 
 export class SqlUpdateInputProcessor implements UpdateInputProcessor<SqlUpdateInputProcessorResult> {
 	private oneHasOneInverseUpdateInputProcessor: OneHasOneInverseUpdateInputProcessor

package/src/mapper/update/UpdateBuilder.ts

@@ -57,93 +57,89 @@ export class UpdateBuilder {
 	}
 
 	public async execute(mapper: Mapper): Promise<UpdateResult> {
-		try {
-			const resolvedData = [...this.rowData.values()]
-			if (Object.keys(resolvedData).length === 0) {
-				return { values: [], affectedRows: null, executed: false }
-			}
-			const oldColSuffix = '_old__'
-
-			const qb = DbUpdateBuilder.create()
-				.with('newData_', qb => {
-					qb = resolvedData.reduce(
-						(qb, value) =>
-							qb
-								.select(
-									expr => expr.selectValue(
+		const resolvedData = [...this.rowData.values()]
+		if (Object.keys(resolvedData).length === 0) {
+			return { values: [], affectedRows: null, executed: false }
+		}
+		const oldColSuffix = '_old__'
+
+		const qb = DbUpdateBuilder.create()
+			.with('newData_', qb => {
+				qb = resolvedData.reduce(
+					(qb, value) =>
+						qb
+							.select(
+								expr =>
+									expr.selectValue(
 										normalizeDbValue(value.value, value.columnType),
 										value.columnType,
 									),
-									value.columnName,
-								)
-								.select(['root_', value.columnName], value.columnName + oldColSuffix),
-						qb,
-					)
-					const columns = new Set(resolvedData.map(it => it.columnName))
-					const allColumns: string[] = Object.values(
-						acceptEveryFieldVisitor(this.schema, this.entity, {
-							visitColumn: ({ column }) => column.columnName,
-							visitManyHasOne: ({ relation }) => relation.joiningColumn.columnName,
-							visitOneHasOneOwning: ({ relation }) => relation.joiningColumn.columnName,
-							visitManyHasManyInverse: () => null,
-							visitManyHasManyOwning: () => null,
-							visitOneHasOneInverse: () => null,
-							visitOneHasMany: () => null,
-						}),
-					).filter((it): it is string => it !== null)
-
-					const remainingColumns = allColumns.filter(it => !columns.has(it))
-					qb = qb.from(this.entity.tableName, 'root_')
-
-					qb = remainingColumns.reduce((qb, columnName) => qb.select(['root_', columnName]), qb)
-
-					qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), {
-						and: [{
-							[this.entity.primary]: { eq: this.primary },
-						}, this.oldWhere],
-					})
-
-					return qb
-				})
-				.table(this.entity.tableName)
-				.values(
-					resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
-						(result: object, item) => ({
-							...result,
-							[item.columnName]: expr => expr.select(['newData_', item.columnName]),
-						}),
-						{},
-					),
+								value.columnName,
+							)
+							.select(['root_', value.columnName], value.columnName + oldColSuffix),
+					qb,
 				)
-				.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
-				.from(qb => {
-					qb = qb.from('newData_')
-					const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
-					const col2 = tuple('newData_', this.entity.primaryColumn)
-					qb = qb.where(expr => expr.compareColumns(col1, Operator.eq, col2))
-					qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([], 'newData_'), this.newWhere)
-					return qb
+				const columns = new Set(resolvedData.map(it => it.columnName))
+				const allColumns: string[] = Object.values(
+					acceptEveryFieldVisitor(this.schema, this.entity, {
+						visitColumn: ({ column }) => column.columnName,
+						visitManyHasOne: ({ relation }) => relation.joiningColumn.columnName,
+						visitOneHasOneOwning: ({ relation }) => relation.joiningColumn.columnName,
+						visitManyHasManyInverse: () => null,
+						visitManyHasManyOwning: () => null,
+						visitOneHasOneInverse: () => null,
+						visitOneHasMany: () => null,
+					}),
+				).filter((it): it is string => it !== null)
+
+				const remainingColumns = allColumns.filter(it => !columns.has(it))
+				qb = qb.from(this.entity.tableName, 'root_')
+
+				qb = remainingColumns.reduce((qb, columnName) => qb.select(['root_', columnName]), qb)
+
+				qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), {
+					and: [{
+						[this.entity.primary]: { eq: this.primary },
+					}, this.oldWhere],
 				})
 
-
-			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData, this.primary)
-			await mapper.eventManager.fire(beforeEvent)
-
-			const result = await qb.execute(mapper.db)
-
-			if (result.length === 1) {
-				const eventData = (resolvedData).map(it => ({
-					...it,
-					old: result[0][it.columnName + oldColSuffix],
-				}))
-				const afterUpdateEvent = new AfterUpdateEvent(this.entity, eventData, this.primary)
-				beforeEvent.afterEvent = afterUpdateEvent
-				await mapper.eventManager.fire(afterUpdateEvent)
-			}
-
-			return { values: resolvedData, affectedRows: result.length, executed: true }
-		} catch (e) {
-			throw e
+				return qb
+			})
+			.table(this.entity.tableName)
+			.values(
+				resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
+					(result: object, item) => ({
+						...result,
+						[item.columnName]: expr => expr.select(['newData_', item.columnName]),
+					}),
+					{},
+				),
+			)
+			.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
+			.from(qb => {
+				qb = qb.from('newData_')
+				const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
+				const col2 = tuple('newData_', this.entity.primaryColumn)
+				qb = qb.where(expr => expr.compareColumns(col1, Operator.eq, col2))
+				qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([], 'newData_'), this.newWhere)
+				return qb
+			})
+
+		const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData, this.primary)
+		await mapper.eventManager.fire(beforeEvent)
+
+		const result = await qb.execute(mapper.db)
+
+		if (result.length === 1) {
+			const eventData = resolvedData.map(it => ({
+				...it,
+				old: result[0][it.columnName + oldColSuffix],
+			}))
+			const afterUpdateEvent = new AfterUpdateEvent(this.entity, eventData, this.primary)
+			beforeEvent.afterEvent = afterUpdateEvent
+			await mapper.eventManager.fire(afterUpdateEvent)
 		}
+
+		return { values: resolvedData, affectedRows: result.length, executed: true }
 	}
 }

package/src/mapper/update/Updater.ts

@@ -1,21 +1,24 @@
 import { SqlUpdateInputProcessor, SqlUpdateInputProcessorResult } from './SqlUpdateInputProcessor'
 import { UpdateInputVisitor } from '../../inputProcessing'
 import { Input, Model } from '@contember/schema'
-import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason } from '../Result'
+import {
+	MutationEntryNotFoundError,
+	MutationNoResultError,
+	MutationNothingToDo,
+	MutationResultList,
+	MutationUpdateOk,
+	NothingToDoReason,
+} from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
-import { DatabaseMetadata } from '@contember/database'
 import { MapperInput } from '../types'
 
 export class Updater {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly schemaDatabaseMetadata: DatabaseMetadata,
-		private readonly predicateFactory: PredicateFactory,
 		private readonly updateBuilderFactory: UpdateBuilderFactory,
 	) {}
 
@@ -66,6 +69,21 @@ export class Updater {
 		const result = await updateBuilder.execute(mapper)
 
 		if (!result.executed) {
+			if (filter && Object.keys(filter).length > 0) {
+				// direct update was not invoked, but we still need to check if the row matches the filter
+				const where: Input.OptionalWhere = {
+					and: [
+						filter,
+						{
+							[entity.primary]: { eq: primaryValue },
+						},
+					],
+				}
+				const count = await mapper.count(entity, where)
+				if (!count) {
+					return [new MutationEntryNotFoundError([], where)]
+				}
+			}
 			resultList.unshift(new MutationNothingToDo([], NothingToDoReason.noData))
 		} else if (result.affectedRows !== 1) {
 			return [new MutationNoResultError([])]

package/src/mapper/update/relations/ManyHasOneUpdateInputProcessor.ts

@@ -16,8 +16,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.ManyHasOneContext
 
-export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
-
+export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 		private readonly builder: UpdateBuilder,
@@ -93,8 +92,7 @@ export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasO
 			return insertResult
 		}
 
-		return async () =>
-			await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), update)
+		return async () => await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), update)
 	}
 
 	public async disconnect(

package/src/mapper/update/relations/OneHasManyUpdateInputProcessor.ts

@@ -8,7 +8,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasManyContext
 
-export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 	) {
@@ -75,7 +75,7 @@ export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasM
 				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
 				{
 					...update,
-				// [targetRelation.name]: {connect: thisPrimary}
+					// [targetRelation.name]: {connect: thisPrimary}
 				},
 			)
 			if (result[0].result === MutationResultType.notFoundError) {

package/src/mapper/update/relations/OneHasOneInverseUpdateInputProcessor.ts

@@ -15,14 +15,16 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneInverseContext
 
-export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasOneInverseUpdateInputProcessor
+	implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>
+{
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
 		private readonly mapper: Mapper,
 	) {
 	}
 
-	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere | CheckedPrimary }) {
+	public async connect({ input, ...ctx }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere | CheckedPrimary }) {
 		return async () => {
 			const [newOwner, err] = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
 			if (err) return [err]
@@ -42,7 +44,6 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		}
 	}
 
-
 	public async create(ctx: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
 		return async () => {
 			return await this.createInternal(ctx)
@@ -156,7 +157,9 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		return result
 	}
 
-	private async createInternal({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
+	private async createInternal(
+		{ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput },
+	) {
 		const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
 			[targetRelation.name]: { [entity.primary]: this.primaryValue },
 		})

package/src/mapper/update/relations/OneHasOneOwningUpdateInputProcessor.ts

@@ -18,7 +18,9 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneOwningContext
 
-export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+export class OneHasOneOwningUpdateInputProcessor
+	implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>
+{
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
 		private readonly mapper: Mapper,
@@ -32,7 +34,8 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		if (err) return [err]
 		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
 		const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
-		if (currentOwnerResult.some(it => it.error)
+		if (
+			currentOwnerResult.some(it => it.error)
 			|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
 		) {
 			return currentOwnerResult
@@ -66,14 +69,17 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		}
 	}
 
-	public async connectOrCreate({ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: MapperInput.ConnectOrCreateInput }) {
+	public async connectOrCreate(
+		{ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: MapperInput.ConnectOrCreateInput },
+	) {
 		const { relation, targetRelation, targetEntity, entity } = context
 		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
 		const [newInverseSide] = await this.mapper.getPrimaryValue(targetEntity, connect)
 
 		if (newInverseSide) {
 			const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
-			if (currentOwnerResult.some(it => it.error)
+			if (
+				currentOwnerResult.some(it => it.error)
 				|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
 			) {
 				return currentOwnerResult
@@ -85,7 +91,6 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 					...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
 				]
 			}
-
 		}
 
 		const createResult = await this.createInternal({ ...context, input: create }, currentInverseSide)
@@ -116,7 +121,9 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		}
 	}
 
-	public async upsert({ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput }) {
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput },
+	) {
 		const primary = await this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
 		if (!primary) {
 			const insertResult = await this.mapper.insert(targetEntity, create)
@@ -184,14 +191,22 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		return await this.mapper.insert(targetEntity, input)
 	}
 
-	private async getCurrentInverseSide(targetRelation: Model.OneHasOneInverseRelation | null, relation: Model.OneHasOneOwningRelation, entity: Model.Entity) {
+	private async getCurrentInverseSide(
+		targetRelation: Model.OneHasOneInverseRelation | null,
+		relation: Model.OneHasOneOwningRelation,
+		entity: Model.Entity,
+	) {
 		if ((targetRelation && !targetRelation.nullable) || relation.orphanRemoval) {
 			return this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
 		}
 		return undefined
 	}
 
-	private async cleanupOrphan(relation: Model.OneHasOneOwningRelation, targetEntity: Model.Entity, currentInverseSide: Input.PrimaryValue | undefined) {
+	private async cleanupOrphan(
+		relation: Model.OneHasOneOwningRelation,
+		targetEntity: Model.Entity,
+		currentInverseSide: Input.PrimaryValue | undefined,
+	) {
 		if (relation.orphanRemoval && currentInverseSide) {
 			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: currentInverseSide })
 		}
@@ -203,7 +218,6 @@ export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor
 		currentInverseSide: Input.PrimaryValue | undefined,
 		newInverseSide: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-
 		if (currentInverseSide === newInverseSide) {
 			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
 		}

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -21,7 +21,6 @@ type NodeFilter = (node: GraphQlFieldNode, path: string[]) => boolean
 type AnyNode = ObjectNode | FieldNode
 
 export class GraphQlQueryAstFactory {
-
 	public create<Args = any>(info: GraphQLResolveInfo, filter?: NodeFilter): ObjectNode<Args> {
 		const node = ResolveInfoUtils.extractFieldNode(info)
 		const parentType = info.parentType

package/src/resolvers/MutationResolver.ts

@@ -44,11 +44,11 @@ export class MutationResolver {
 	public async resolveTransaction(info: GraphQLResolveInfo, options: TransactionOptions): Promise<Result.TransactionResult> {
 		const queryAst = this.graphqlQueryAstFactory.create(info, (node, path) => {
 			return (
-				(path.length === 1 && !['ok', 'validation', 'errorMessage', 'errors'].includes(node.name.value)) ||
-				(path.length === 2 && node.name.value === 'node') ||
-				path.length > 2 ||
-				path.length === 0 ||
-				(path.length > 1 && path[1] === 'query')
+				(path.length === 1 && !['ok', 'validation', 'errorMessage', 'errors'].includes(node.name.value))
+				|| (path.length === 2 && node.name.value === 'node')
+				|| path.length > 2
+				|| path.length === 0
+				|| (path.length > 1 && path[1] === 'query')
 			)
 		})
 		const fields = GraphQlQueryAstFactory.resolveObjectType(info.returnType).getFields()
@@ -189,7 +189,7 @@ export class MutationResolver {
 							? {
 								valid: result.validation.valid,
 								errors: validationErrors,
-							  }
+							}
 							: { valid: true, errors: [] },
 						errorMessage: [
 							this.stringifyValidationErrors(validationErrors),
@@ -429,8 +429,8 @@ export class MutationResolver {
 
 		const result = await mapper.delete(entity, queryAst.args.by, queryAst.args.filter)
 		if (
-			result.length >= 1 &&
-			(result[0].result === MutationResultType.ok || result[0].result === MutationResultType.nothingToDo)
+			result.length >= 1
+			&& (result[0].result === MutationResultType.ok || result[0].result === MutationResultType.nothingToDo)
 		) {
 			return { ok: true, errors: [], ...nodes }
 		} else {
@@ -492,7 +492,6 @@ export class MutationResolver {
 							}
 							return { ...result, ...errorResponse }
 						}
-
 					}
 					return result
 				})
@@ -504,7 +503,6 @@ export class MutationResolver {
 				maxTimeout: 1000,
 			},
 		)
-
 	}
 
 	private createErrorResponse(result: MutationResultList) {
@@ -545,7 +543,7 @@ export class MutationResolver {
 				path.map(it => ({
 					...it,
 					__typename: 'field' in it ? '_FieldPathFragment' : '_IndexPathFragment',
-				})),
+				}))
 			)
 			const path = paths[0] || []
 			switch (it.result) {
@@ -594,8 +592,8 @@ export class MutationResolver {
 			return undefined
 		}
 		return (
-			'Validation has failed:\n' +
-			validationErrors.map(it => `${this.stringifyPath(it.path)}: ${it.message.text}`).join('\n')
+			'Validation has failed:\n'
+			+ validationErrors.map(it => `${this.stringifyPath(it.path)}: ${it.message.text}`).join('\n')
 		)
 	}
 
@@ -604,8 +602,8 @@ export class MutationResolver {
 			return undefined
 		}
 		return (
-			'Execution has failed:\n' +
-			executionErrors.map(it => `${this.stringifyPath(it.paths[0] || [])}: ${it.type} (${it.message || ''})`)
+			'Execution has failed:\n'
+			+ executionErrors.map(it => `${this.stringifyPath(it.paths[0] || [])}: ${it.type} (${it.message || ''})`)
 		)
 	}
 

package/src/resolvers/RefreshViewResolver.ts

@@ -1,7 +1,6 @@
 import { Schema } from '@contember/schema'
 import { MapperFactory } from '../mapper'
 import { wrapIdentifier } from '@contember/database'
-import { Authorizator } from '../acl'
 
 export class RefreshViewResolver {
 	constructor(
@@ -10,13 +9,14 @@ export class RefreshViewResolver {
 	) {
 	}
 
-	public async resolve(entity: string): Promise<{ ok: boolean }> {
+	public async resolve(entity: string, options?: { concurrently?: boolean }): Promise<{ ok: boolean }> {
 		const mapper = this.mapperFactory.create()
 		const entityModel = this.schema.model.entities[entity]
 		if (!entityModel) {
 			throw new Error(`Entity ${entity} not found`)
 		}
-		await mapper.db.query(`REFRESH MATERIALIZED VIEW ${wrapIdentifier(entityModel.tableName)}`)
+		const concurrently = options?.concurrently ? ' CONCURRENTLY' : ''
+		await mapper.db.query(`REFRESH MATERIALIZED VIEW${concurrently} ${wrapIdentifier(mapper.db.schema)}.${wrapIdentifier(entityModel.tableName)}`)
 
 		return { ok: true }
 	}

package/src/schema/ColumnTypeResolver.ts

@@ -93,7 +93,7 @@ export class ColumnTypeResolver {
 			case Model.ColumnType.Json:
 				return this.customTypeProvider.jsonType
 			default:
-				(({}: never): never => {
+				;(({}: never): never => {
 					throw new ImplementationException('Invalid column type')
 				})(type)
 		}

package/src/schema/ConditionTypeProvider.ts

@@ -60,6 +60,9 @@ export class ConditionTypeProvider {
 						conditions.lte = { type: type }
 						conditions.gt = { type: type }
 						conditions.gte = { type: type }
+					} else {
+						// For JSON columns, add the includes operator
+						conditions.includes = { type: type }
 					}
 					if (column.type === Model.ColumnType.String) {
 						conditions.contains = { type: GraphQLString }
@@ -72,7 +75,6 @@ export class ConditionTypeProvider {
 					}
 				}
 
-
 				return conditions
 			},
 		})

package/src/schema/CustomTypesProvider.ts

@@ -20,11 +20,10 @@ function validateTime(value: unknown): string {
 	return `${hours}:${minutes}:${seconds}${fraction}`
 }
 
-
 export class CustomTypesProvider {
 	public readonly uuidType: GraphQLScalarType = UuidType
 
-	//todo: implement serialize, parseValue and parseLiteral properly
+	// todo: implement serialize, parseValue and parseLiteral properly
 
 	public readonly dateType: GraphQLScalarType = new GraphQLScalarType({
 		name: 'Date',

package/src/schema/EntityTypeProvider.ts

@@ -77,9 +77,7 @@ export class EntityTypeProvider {
 	private getEntityFields(entityName: string) {
 		const entity = getEntityFromSchema(this.schema, entityName)
 		const accessVisitor = new FieldAccessVisitor(Acl.Operation.read, this.authorizator)
-		const accessibleFields = Object.values(entity.fields).filter(field =>
-			acceptFieldVisitor(this.schema, entity, field.name, accessVisitor),
-		)
+		const accessibleFields = Object.values(entity.fields).filter(field => acceptFieldVisitor(this.schema, entity, field.name, accessVisitor))
 		const metaFields: { [field: string]: GraphQLFieldConfig<any, any> } = {}
 		for (const field of accessibleFields) {
 			metaFields[field.name] = {