@contember/engine-content-api 2.1.0-alpha.9 → 2.1.0-beta.1

package/src/mapper/ColumnValue.ts

@@ -7,7 +7,6 @@ export type ColumnValue = {
 	columnType: string
 }
 
-
 export const rowDataToFieldValues = (values: ColumnValue[]): Record<string, Value.FieldValue> =>
 	Object.fromEntries(values.map(it => [it.fieldName, it.value]))
 

package/src/mapper/ErrorUtils.ts

@@ -15,7 +15,6 @@ import { acceptFieldVisitor, tryGetColumnName } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
 import { DatabaseMetadata } from '@contember/database'
 
-
 type UniqueConstraintResult = {
 	entity: Model.Entity
 	fields: string[]
@@ -23,7 +22,12 @@ type UniqueConstraintResult = {
 
 const getEntityByTableName = (model: Model.Schema, tableName: string) => Object.values(model.entities).find(it => it.tableName === tableName)
 
-const findUniqueConstraint = (model: Model.Schema, databaseMetadata: DatabaseMetadata, tableName: string, constraintName: string): UniqueConstraintResult | null => {
+const findUniqueConstraint = (
+	model: Model.Schema,
+	databaseMetadata: DatabaseMetadata,
+	tableName: string,
+	constraintName: string,
+): UniqueConstraintResult | null => {
 	const constraint = databaseMetadata.uniqueConstraints.filter({ tableName, constraintName }).first()
 	if (!constraint) {
 		return null
@@ -51,7 +55,12 @@ type RelationInfo = {
 	targetEntity: Model.Entity
 }
 
-const findForeignConstraint = (model: Model.Schema, databaseMetadata: DatabaseMetadata, tableName: string, constraintName: string): RelationInfo | null => {
+const findForeignConstraint = (
+	model: Model.Schema,
+	databaseMetadata: DatabaseMetadata,
+	tableName: string,
+	constraintName: string,
+): RelationInfo | null => {
 	const constraint = databaseMetadata.foreignKeys.filter({ fromTable: tableName, constraintName }).first()
 	if (!constraint) {
 		return null
@@ -92,7 +101,6 @@ export const convertError = (
 	databaseMetadata: DatabaseMetadata,
 	e: any,
 ): MutationResult => {
-
 	if (e instanceof Database.NotNullViolationError) {
 		return new MutationConstraintViolationError([], ConstraintType.notNull, e.originalMessage, [
 			MutationResultHint.sqlError,
@@ -116,8 +124,8 @@ export const convertError = (
 		const matchResult = violationDetail.match(/^Key \(.+\)=\((.+)\) already exists\.$/)
 		const values = matchResult?.[1]
 		const message = constraint
-			? `${values ? `Value (${values})` : 'Unknown value'}` +
-			  ` already exists in unique columns (${constraint.fields.join(', ')}) on entity ${constraint.entity.name}`
+			? `${values ? `Value (${values})` : 'Unknown value'}`
+				+ ` already exists in unique columns (${constraint.fields.join(', ')}) on entity ${constraint.entity.name}`
 			: e.originalMessage
 		const paths = constraint ? constraint.fields.map(it => [{ field: it }]) : []
 		return new MutationConstraintViolationError(paths, ConstraintType.uniqueKey, message, [MutationResultHint.sqlError])
@@ -141,7 +149,11 @@ export const convertError = (
 	throw e
 }
 
-export const tryMutation = async (schema: Model.Schema, databaseMetadata: DatabaseMetadata, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
+export const tryMutation = async (
+	schema: Model.Schema,
+	databaseMetadata: DatabaseMetadata,
+	cb: () => Promise<MutationResultList>,
+): Promise<MutationResultList> => {
 	try {
 		return await cb()
 	} catch (e) {

package/src/mapper/EventManager.ts

@@ -25,7 +25,6 @@ export class AfterInsertEvent {
 	}
 }
 
-
 export class BeforeUpdateEvent {
 	public type = 'BeforeUpdateEvent' as const
 
@@ -81,7 +80,6 @@ export class BeforeJunctionUpdateEvent {
 	}
 }
 
-
 export class AfterJunctionUpdateEvent {
 	public type = 'AfterJunctionUpdateEvent' as const
 

package/src/mapper/JunctionTableManager.ts

@@ -1,15 +1,7 @@
 import { getEntity } from '@contember/schema-utils'
 import { PathFactory, WhereBuilder } from './select'
 import { PredicateFactory } from '../acl'
-import {
-	Client,
-	ConflictActionType,
-	DeleteBuilder,
-	InsertBuilder,
-	Literal,
-	Operator,
-	SelectBuilder,
-} from '@contember/database'
+import { Client, ConflictActionType, DeleteBuilder, InsertBuilder, Literal, Operator, SelectBuilder } from '@contember/database'
 import { Acl, Input, Model } from '@contember/schema'
 import {
 	MutationJunctionUpdateOk,
@@ -58,7 +50,14 @@ export class JunctionTableManager {
 			this.connectJunctionHandler,
 		)
 		if (result.result !== MutationResultType.noResultError) {
-			const afterEvent = new AfterJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'connect', result.result === MutationResultType.ok)
+			const afterEvent = new AfterJunctionUpdateEvent(
+				owningEntity,
+				relation,
+				owningUnique,
+				inverseUnique,
+				'connect',
+				result.result === MutationResultType.ok,
+			)
 			await mapper.eventManager.fire(afterEvent)
 		}
 		return [result]
@@ -82,14 +81,20 @@ export class JunctionTableManager {
 			this.disconnectJunctionHandler,
 		)
 		if (result.result !== MutationResultType.noResultError) {
-			const afterEvent = new AfterJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'disconnect', result.result === MutationResultType.ok)
+			const afterEvent = new AfterJunctionUpdateEvent(
+				owningEntity,
+				relation,
+				owningUnique,
+				inverseUnique,
+				'disconnect',
+				result.result === MutationResultType.ok,
+			)
 			beforeEvent.afterEvent = afterEvent
 			await mapper.eventManager.fire(afterEvent)
 		}
 		return [result]
 	}
 
-
 	private async executeJunctionModification(
 		db: Client,
 		owningEntity: Model.Entity,
@@ -112,8 +117,7 @@ export class JunctionTableManager {
 
 		const hasNoPredicates = Object.keys(owningPredicate).length === 0 && Object.keys(inversePredicate).length === 0
 
-		const okResultFactory = () =>
-			new MutationJunctionUpdateOk([], owningEntity, relation, owningPrimary, inversePrimary)
+		const okResultFactory = () => new MutationJunctionUpdateOk([], owningEntity, relation, owningPrimary, inversePrimary)
 		if (hasNoPredicates) {
 			return await handler.executeSimple({ db, joiningTable, owningPrimary, inversePrimary, okResultFactory })
 		} else {
@@ -134,7 +138,6 @@ export class JunctionTableManager {
 					)
 					.select(expr => expr.raw('true'), 'selected')
 					.from(new Literal('(values (null))'), 't')
-
 					.join(owningEntity.tableName, 'owning', condition => condition.raw('true'))
 					.join(inverseEntity.tableName, 'inverse', condition => condition.raw('true'))
 				qb = this.whereBuilder.build(qb, owningEntity, this.pathFactory.create([], 'owning'), owningWhere)
@@ -200,8 +203,7 @@ export class JunctionConnectHandler implements JunctionHandler {
 			.into(joiningTable.tableName)
 			.values({
 				[joiningTable.joiningColumn.columnName]: expr => expr.select(['data', joiningTable.joiningColumn.columnName]),
-				[joiningTable.inverseJoiningColumn.columnName]: expr =>
-					expr.select(['data', joiningTable.inverseJoiningColumn.columnName]),
+				[joiningTable.inverseJoiningColumn.columnName]: expr => expr.select(['data', joiningTable.inverseJoiningColumn.columnName]),
 			})
 			.returning(new Literal('true as inserted'))
 			.from(qb => qb.from('data'))

package/src/mapper/Mapper.ts

@@ -82,7 +82,11 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		return await hydrator.hydrateAll(rows, indexByAlias)
 	}
 
-	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>, relationPath: Model.AnyRelationContext[]): Promise<SelectResultObject[]> {
+	public async select(
+		entity: Model.Entity,
+		input: ObjectNode<Input.ListQueryInput>,
+		relationPath: Model.AnyRelationContext[],
+	): Promise<SelectResultObject[]> {
 		const hydrator = new SelectHydrator()
 		const qb: SelectBuilder<SelectBuilder.Result> = SelectBuilder.create()
 
@@ -135,7 +139,12 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		const augmentedBuilder = qb.from(entity.tableName, path.alias).meta('path', [...input.path, input.alias])
 
 		const selector = this.selectBuilderFactory.create(augmentedBuilder, hydrator, relationPath)
-		const filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {}, relationPath[relationPath.length - 1])
+		const filterWithPredicates = this.predicatesInjector.inject(
+			entity,
+			inputWithOrder.args.filter || {},
+			relationPath[relationPath.length - 1],
+			relationPath,
+		)
 		const inputWithPredicates = inputWithOrder.withArg('filter', filterWithPredicates)
 		selector.select(this, entity, inputWithPredicates, path, groupBy)
 		return await selector.execute(this.db)
@@ -164,7 +173,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			.select(expr => expr.raw('count(*)'), 'row_count')
 			.select([path.alias, relation.joiningColumn.columnName])
 			.groupBy([path.alias, relation.joiningColumn.columnName])
-		const withPredicates = this.predicatesInjector.inject(entity, filter, relationPath[relationPath.length - 1])
+		const withPredicates = this.predicatesInjector.inject(entity, filter, relationPath[relationPath.length - 1], relationPath)
 		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates, { relationPath })
 		const rows = await qbWithWhere.getResult(this.db)
 		const result = new Map<string, number>()
@@ -183,9 +192,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			throw new ImplementationException()
 		}
 		await this.setupSystemVariables()
-		return tryMutation(this.schema, this.schemaDatabaseMetadata, () =>
-			this.insertInternal(entity, data, builderCb),
-		)
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, () => this.insertInternal(entity, data, builderCb))
 	}
 
 	public async update(

package/src/mapper/MapperFactory.ts

@@ -13,7 +13,6 @@ import { Providers } from '@contember/schema-utils'
 export type MapperFactoryHook = (mapper: Mapper) => void
 
 export class MapperFactory {
-
 	public readonly hooks: MapperFactoryHook[] = []
 
 	constructor(

package/src/mapper/Result.ts

@@ -178,7 +178,7 @@ export class MutationEntryNotFoundError implements MutationResultInterface {
 	hints: MutationResultHint[] = []
 	message: string
 
-	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere | Input.Where) {
+	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere | Input.OptionalWhere) {
 		this.message = 'for input ' + JSON.stringify(where)
 	}
 }
@@ -202,6 +202,6 @@ export const prependPath = (path: Path, results: MutationResultList): MutationRe
 	}))
 
 export const getInsertPrimary = (result: MutationResultList) =>
-	result[0] && result[0].result === MutationResultType.ok && result[0].type === ModificationType.create
+	!result.some(it => it.error) && result[0] && result[0].result === MutationResultType.ok && result[0].type === ModificationType.create
 		? result[0].primary
 		: undefined

package/src/mapper/delete/DeleteExecutor.ts

@@ -158,7 +158,6 @@ export class DeleteExecutor {
 		return await this.processDeleteResult(state, mapper, entity, result, orphanRemovals)
 	}
 
-
 	private async collectOnDeleteInfo(state: DeleteState, mapper: Mapper, entity: Model.Entity, values: Input.PrimaryValue[]): Promise<void> {
 		if (values.length === 0) {
 			return
@@ -210,7 +209,6 @@ export class DeleteExecutor {
 		await this.processDeleteResult(state, mapper, entity, result, orphanRemovals)
 	}
 
-
 	private async collectSetNullResult(
 		state: DeleteState,
 		mapper: Mapper,
@@ -240,7 +238,6 @@ export class DeleteExecutor {
 		state.pushFailResult(new MutationConstraintViolationError([], ConstraintType.foreignKey, message))
 	}
 
-
 	private async collectRestrictResult(
 		state: DeleteState,
 		mapper: Mapper,
@@ -278,7 +275,6 @@ export class DeleteExecutor {
 			const entity = getEntity(this.schema, orphanRemoval[0])
 			const orphanResult = await this.collectDeleteInfo(state, mapper, entity, { [entity.primary]: { in: orphanRemoval[1] } })
 			deleteQueue.push([entity, orphanResult])
-
 		} while (true)
 	}
 
@@ -294,7 +290,11 @@ export class DeleteExecutor {
 		return orphanColumns.reduce((qb, column) => qb.select(['root_', column], `_${column}`), qb)
 	}
 
-	private createFetchByIdQueryBuilder(entity: Model.Entity, relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation, values: Input.PrimaryValue[]) {
+	private createFetchByIdQueryBuilder(
+		entity: Model.Entity,
+		relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation,
+		values: Input.PrimaryValue[],
+	) {
 		return SelectBuilder.create<EntityReferenceRow>()
 			.from(entity.tableName, 'root_')
 			.select(['root_', entity.primaryColumn], 'id')
@@ -302,11 +302,10 @@ export class DeleteExecutor {
 			.where(expr => expr.in(['root_', relation.joiningColumn.columnName], values))
 	}
 
-	private filterPlannedForDelete<R extends {id: Input.PrimaryValue}>(state: DeleteState, entity: Model.Entity, values: R[]): R[] {
+	private filterPlannedForDelete<R extends { id: Input.PrimaryValue }>(state: DeleteState, entity: Model.Entity, values: R[]): R[] {
 		return values.filter(it => !state.isPlannedDelete(entity.name, it.id))
 	}
 
-
 	private async processDeleteResult(
 		state: DeleteState,
 		mapper: Mapper,

package/src/mapper/delete/DeleteState.ts

@@ -33,7 +33,6 @@ export class DeleteState {
 		this.failResult.push(...Array.isArray(result) ? result : [result])
 	}
 
-
 	public isPlannedDelete(entityName: string, primary: Input.PrimaryValue): boolean {
 		return this.plannedDelete.isDeleted(entityName, primary)
 	}

package/src/mapper/delete/helpers.ts

@@ -11,8 +11,7 @@ export const findRelationsWithOrphanRemoval = (schema: Model.Schema, entity: Mod
 			visitManyHasManyOwning: () => null,
 			visitOneHasOneInverse: () => null,
 			visitOneHasMany: () => null,
-			visitOneHasOneOwning: ({ relation, targetEntity }) =>
-				relation.orphanRemoval ? [targetEntity, relation] : null,
+			visitOneHasOneOwning: ({ relation, targetEntity }) => relation.orphanRemoval ? [targetEntity, relation] : null,
 			visitManyHasOne: () => null,
 		}),
 	).filter((it): it is OneHasOneOwningRelationTuple => it !== null)
@@ -31,7 +30,7 @@ export const findOwningRelations = (schema: Model.Schema, entity: Model.Entity):
 				visitOneHasMany: () => null,
 				visitOneHasOneOwning: ({ relation }): EntityOwningRelationTuple => [entity, relation],
 				visitManyHasOne: ({ relation }): EntityOwningRelationTuple => [entity, relation],
-			}),
+			})
 		)
 		.reduce<EntityOwningRelationTuple[]>(
 			(acc, value) => [

package/src/mapper/insert/InsertBuilder.ts

@@ -47,48 +47,45 @@ export class InsertBuilder {
 	}
 
 	public async execute(mapper: Mapper): Promise<InsertResult> {
-		try {
-			const resolvedData = [...this.rowData.values()]
+		const resolvedData = [...this.rowData.values()]
 
-			const insertData = resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
-				(result, item) => ({ ...result, [item.columnName]: expr => expr.select(['root_', item.columnName]) }),
-				{},
-			)
-			const qb = DbInsertBuilder.create()
-				.with('root_', qb => {
-					return resolvedData.reduce(
-						(qb, value) =>
-							qb.select(
-								expr => expr.selectValue(
+		const insertData = resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
+			(result, item) => ({ ...result, [item.columnName]: expr => expr.select(['root_', item.columnName]) }),
+			{},
+		)
+		const qb = DbInsertBuilder.create()
+			.with('root_', qb => {
+				return resolvedData.reduce(
+					(qb, value) =>
+						qb.select(
+							expr =>
+								expr.selectValue(
 									normalizeDbValue(value.value, value.columnType),
 									value.columnType,
 								),
-								value.columnName,
-							),
-						qb,
-					)
-				})
-				.into(this.entity.tableName)
-				.values(insertData)
-				.from(qb => {
-					qb = qb.from('root_')
-					return this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), this.where)
-				})
-				.returning(this.entity.primaryColumn)
+							value.columnName,
+						),
+					qb,
+				)
+			})
+			.into(this.entity.tableName)
+			.values(insertData)
+			.from(qb => {
+				qb = qb.from('root_')
+				return this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), this.where)
+			})
+			.returning(this.entity.primaryColumn)
 
-			const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData)
-			await mapper.eventManager.fire(beforeInsertEvent)
+		const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData)
+		await mapper.eventManager.fire(beforeInsertEvent)
 
-			const returning = (await qb.execute(mapper.db)).map(it => it[this.entity.primaryColumn])
-			const result = returning.length === 1 ? returning[0] : null
+		const returning = (await qb.execute(mapper.db)).map(it => it[this.entity.primaryColumn])
+		const result = returning.length === 1 ? returning[0] : null
 
-			const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData, result)
-			beforeInsertEvent.afterEvent = afterInsertEvent
-			await mapper.eventManager.fire(afterInsertEvent)
+		const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData, result)
+		beforeInsertEvent.afterEvent = afterInsertEvent
+		await mapper.eventManager.fire(afterInsertEvent)
 
-			return { values: resolvedData, executed: true, primaryValue: result }
-		} catch (e) {
-			throw e
-		}
+		return { values: resolvedData, executed: true, primaryValue: result }
 	}
 }

package/src/mapper/insert/Inserter.ts

@@ -90,4 +90,3 @@ export class Inserter {
 		return resultList
 	}
 }
-

package/src/mapper/insert/SqlCreateInputProcessor.ts

@@ -11,13 +11,11 @@ import { OneHasManyCreateInputProcessor } from './relations/OneHasManyCreateInpu
 import { ManyHasOneCreateInputProcessor } from './relations/ManyHasOneCreateInputProcessor'
 import { ManyHasManyCreateInputProcessor } from './relations/ManyHasManyCreateInputProcessor'
 
-
 export type SqlCreateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue }) => Promise<MutationResultList>)
 export class SqlCreateInputProcessor implements CreateInputProcessor<SqlCreateInputProcessorResult> {
-
-	private oneHasOneInverseCreateInputProcessor:  OneHasOneInverseCreateInputProcessor
-	private oneHasOneOwningCreateInputProcessor:  OneHasOneOwningCreateInputProcessor
-	private oneHasManyCreateInputProcessor:  OneHasManyCreateInputProcessor
+	private oneHasOneInverseCreateInputProcessor: OneHasOneInverseCreateInputProcessor
+	private oneHasOneOwningCreateInputProcessor: OneHasOneOwningCreateInputProcessor
+	private oneHasManyCreateInputProcessor: OneHasManyCreateInputProcessor
 	private manyHasOneCreateInputProcessor: ManyHasOneCreateInputProcessor
 	private manyHasManyCreateInputProcessor: ManyHasManyCreateInputProcessor
 
@@ -70,7 +68,6 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<SqlCreateIn
 		connectOrCreate: hasManyProcessor(ctx => this.oneHasManyCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-
 	oneHasOneOwning: CreateInputProcessor<SqlCreateInputProcessorResult>['oneHasOneOwning'] = {
 		nothing: async ctx => {
 			this.insertBuilder.addFieldValue(ctx.relation.name, null)

package/src/mapper/insert/relations/ManyHasManyCreateInputProcessor.ts

@@ -9,7 +9,6 @@ import { MapperInput } from '../../types'
 type Context = Model.ManyHasManyOwningContext | Model.ManyHasManyInverseContext
 
 export class ManyHasManyCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult> {
-
 	constructor(
 		private readonly mapper: Mapper,
 	) {

package/src/mapper/insert/relations/ManyHasOneCreateInputProcessor.ts

@@ -9,8 +9,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.ManyHasOneContext
 
-export class ManyHasOneCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult>  {
-
+export class ManyHasOneCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 		private readonly insertBuilder: InsertBuilder,

package/src/mapper/insert/relations/OneHasManyCreateInputProcessor.ts

@@ -8,7 +8,6 @@ import { MapperInput } from '../../types'
 type Context = Model.OneHasManyContext
 
 export class OneHasManyCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult> {
-
 	constructor(
 		private readonly mapper: Mapper,
 	) {

package/src/mapper/insert/relations/OneHasOneInverseCreateInputProcessor.ts

@@ -8,8 +8,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneInverseContext
 
-export class OneHasOneInverseCreateInputProcessor implements CreateInputProcessor.HasOneRelationProcessor<Context, SqlCreateInputProcessorResult>  {
-
+export class OneHasOneInverseCreateInputProcessor implements CreateInputProcessor.HasOneRelationProcessor<Context, SqlCreateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 	) {
@@ -25,7 +24,6 @@ export class OneHasOneInverseCreateInputProcessor implements CreateInputProcesso
 		}
 	}
 
-
 	public async create(
 		{ input, targetRelation, targetEntity }: Context & { input: MapperInput.CreateDataInput },
 	) {
@@ -54,7 +52,6 @@ export class OneHasOneInverseCreateInputProcessor implements CreateInputProcesso
 		{ entity, targetEntity, targetRelation, relation, input }: Context & { input: CheckedPrimary },
 		primary: Input.PrimaryValue,
 	) {
-
 		const currentInverseSideOfOwner = await this.mapper.selectField(targetEntity, input, targetRelation.name)
 		const orphanResult: MutationResultList = []
 		if (currentInverseSideOfOwner) {

package/src/mapper/insert/relations/OneHasOneOwningCreateInputProcessor.ts

@@ -1,10 +1,4 @@
-import {
-	ConstraintType,
-	getInsertPrimary,
-	MutationConstraintViolationError,
-	MutationEntryNotFoundError,
-	MutationResultList,
-} from '../../Result'
+import { ConstraintType, getInsertPrimary, MutationConstraintViolationError, MutationEntryNotFoundError, MutationResultList } from '../../Result'
 import { InsertBuilder } from '../../insert'
 import { Mapper } from '../../Mapper'
 import { Input, Model } from '@contember/schema'
@@ -15,7 +9,7 @@ import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneOwningContext
 
-export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor.HasOneRelationProcessor<Context, SqlCreateInputProcessorResult>{
+export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor.HasOneRelationProcessor<Context, SqlCreateInputProcessorResult> {
 	constructor(
 		private readonly mapper: Mapper,
 		private readonly insertBuilder: InsertBuilder,
@@ -53,7 +47,6 @@ export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor
 				return disconnectResult
 			}
 			return []
-
 		} else {
 			const insertResult = await this.mapper.insert(context.targetEntity, input.create)
 			const primary = getInsertPrimary(insertResult)

package/src/mapper/select/ConditionBuilder.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { QueryBuilder, ConditionBuilder as SqlConditionBuilder, Operator, Literal, formatColumnIdentifier, Compiler } from '@contember/database'
+import { Compiler, ConditionBuilder as SqlConditionBuilder, formatColumnIdentifier, Literal, Operator, QueryBuilder } from '@contember/database'
 import { UserError } from '../../exception'
 
 export class ConditionBuilder {
@@ -14,16 +14,14 @@ export class ConditionBuilder {
 			return builder
 		}
 		const entries = Object.entries(condition)
-			.filter(<T extends keyof Input.Condition>(it: [string, any]): it is [T, Input.Condition[T]] =>
-				it[1] !== null,
-			)
+			.filter(<T extends keyof Input.Condition>(it: [string, any]): it is [T, Input.Condition[T]] => it[1] !== null)
 		if (entries.length === 0) {
 			return builder
 		}
 		if (entries.length > 1) {
 			throw new UserError(
-				'Only single field is allowed. If you want to combine multiple conditions, use "and" or "or". Got: ' +
-					JSON.stringify(condition),
+				'Only single field is allowed. If you want to combine multiple conditions, use "and" or "or". Got: '
+					+ JSON.stringify(condition),
 			)
 		}
 		const columnIdentifier: QueryBuilder.ColumnIdentifier = [tableName, columnName]
@@ -34,8 +32,10 @@ export class ConditionBuilder {
 				param: Exclude<Input.Condition<any>[K], undefined>,
 			) => SqlConditionBuilder
 		} = {
-			and: (builder, expressions) => builder.and(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
-			or: (builder, expressions) => builder.or(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
+			and: (builder, expressions) =>
+				builder.and(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
+			or: (builder, expressions) =>
+				builder.or(builder2 => expressions.reduce((builder3, expr) => this.build(builder3, tableName, columnName, columnType, expr), builder2)),
 			not: (builder, expression) => builder.not(builder2 => this.build(builder2, tableName, columnName, columnType, expression)),
 
 			isNull: (builder, value) => value ? builder.isNull(columnIdentifier) : builder.not(clause => clause.isNull(columnIdentifier)),
@@ -49,12 +49,18 @@ export class ConditionBuilder {
 			gt: (builder, value) => builder.compare(columnIdentifier, Operator.gt, value),
 			gte: (builder, value) => builder.compare(columnIdentifier, Operator.gte, value),
 
-			includes: (builder, value) => {
-				const cast = columnType.type === Model.ColumnType.Enum
-					? `${Compiler.SCHEMA_PLACEHOLDER}."${columnType.columnType}"`
-					: columnType.columnType
+			includes: (builder, value: any) => {
+				if (columnType.type === Model.ColumnType.Json) {
+					// For JSON columns, use @> operator to check if JSON contains the value
+					return builder.raw(`${formatColumnIdentifier(columnIdentifier)} @> ?::jsonb`, JSON.stringify(value))
+				} else {
+					// For array columns, use @> operator with array casting
+					const cast = columnType.type === Model.ColumnType.Enum
+						? `${Compiler.SCHEMA_PLACEHOLDER}."${columnType.columnType}"`
+						: columnType.columnType
 
-				return builder.raw(`${formatColumnIdentifier(columnIdentifier)} @> ARRAY[?]::${cast}[]`, value)
+					return builder.raw(`${formatColumnIdentifier(columnIdentifier)} @> ARRAY[?]::${cast}[]`, value)
+				}
 			},
 			maxLength: (builder, value) => builder.raw(`array_length(${formatColumnIdentifier(columnIdentifier)}, 1) <= ?`, value),
 			minLength: (builder, value) => builder.raw(`array_length(${formatColumnIdentifier(columnIdentifier)}, 1) >= ?`, value),

package/src/mapper/select/JoinBuilder.ts

@@ -28,8 +28,10 @@ export class JoinBuilder {
 			}
 			const sourceAlias = join.sourceAlias || path.back().alias
 
-			return qb.leftJoin(join.tableName, targetAlias, clause =>
-				clause.compareColumns([sourceAlias, join.sourceColumn], Operator.eq, [targetAlias, join.targetColumn]),
+			return qb.leftJoin(
+				join.tableName,
+				targetAlias,
+				clause => clause.compareColumns([sourceAlias, join.sourceColumn], Operator.eq, [targetAlias, join.targetColumn]),
 			)
 		}, qb)
 	}

package/src/mapper/select/OrderByHelper.ts

@@ -17,8 +17,8 @@ export class OrderByHelper {
 		const hasLimit = typeof objectNode.args.limit === 'number'
 		const hasOffset = typeof objectNode.args.offset === 'number'
 		if (
-			(!hasLimit && !hasOffset && !hasOrderBy) ||
-			(hasOrderBy && (inputOrder[0]._random || inputOrder[0]._randomSeeded !== undefined))
+			(!hasLimit && !hasOffset && !hasOrderBy)
+			|| (hasOrderBy && (inputOrder[0]._random || inputOrder[0]._randomSeeded !== undefined))
 		) {
 			return objectNode
 		}

package/src/mapper/select/Path.ts

@@ -17,8 +17,6 @@ export class AliasContext {
 export class PathFactory {
 	private aliasContext = new AliasContext()
 
-	public constructor() {}
-
 	public create(path: string[], rootAlias = 'root_') {
 		return new Path(path, this.aliasContext, rootAlias)
 	}