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

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)
 	}

package/src/mapper/select/RelationFetcher.ts

@@ -28,13 +28,12 @@ type FetchOneHasManyGroupsArgs = {
 	ids: Input.PrimaryValue[]
 }
 
-type ManyHasManyBaseArgs =
-	& {
-		mapper: Mapper
-		ids: Input.PrimaryValue[]
-		relationPath: Model.AnyRelationContext[]
-		relationContext: Model.ManyHasManyInverseContext | Model.ManyHasManyOwningContext
-	}
+type ManyHasManyBaseArgs = {
+	mapper: Mapper
+	ids: Input.PrimaryValue[]
+	relationPath: Model.AnyRelationContext[]
+	relationContext: Model.ManyHasManyInverseContext | Model.ManyHasManyOwningContext
+}
 type CountManyHasManyGroupArgs =
 	& ManyHasManyBaseArgs
 	& {
@@ -179,14 +178,18 @@ export class RelationFetcher {
 		return this.buildManyHasManyGroups(targetEntity, joiningColumns, result, junctionValues)
 	}
 
-	private resolveJoiningColumns({ relationType, joiningTable }: { joiningTable: Model.JoiningTable; relationType: 'manyHasManyOwning' | 'manyHasManyInverse' }): JoiningColumns {
-		return relationType === 'manyHasManyOwning' ? {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		} : {
-			sourceColumn: joiningTable.inverseJoiningColumn,
-			targetColumn: joiningTable.joiningColumn,
-		}
+	private resolveJoiningColumns(
+		{ relationType, joiningTable }: { joiningTable: Model.JoiningTable; relationType: 'manyHasManyOwning' | 'manyHasManyInverse' },
+	): JoiningColumns {
+		return relationType === 'manyHasManyOwning'
+			? {
+				sourceColumn: joiningTable.joiningColumn,
+				targetColumn: joiningTable.inverseJoiningColumn,
+			}
+			: {
+				sourceColumn: joiningTable.inverseJoiningColumn,
+				targetColumn: joiningTable.joiningColumn,
+			}
 	}
 
 	private buildManyHasManyGroups(
@@ -232,7 +235,7 @@ export class RelationFetcher {
 			['junction_', column.sourceColumn.columnName],
 			(orderable, qb) => {
 				if (object.args.orderBy) {
-					[qb, orderable] = this.orderBuilder.build(
+					;[qb, orderable] = this.orderBuilder.build(
 						qb,
 						orderable,
 						targetEntity,
@@ -268,19 +271,21 @@ export class RelationFetcher {
 
 		const where = this.predicateInjector.inject(targetEntity, objectArgs.filter || {}, relationPath[relationPath.length - 1])
 		const hasWhere = where && Object.keys(where).length > 0
-		const hasFieldOrderBy =
-			objectArgs.orderBy &&
-			objectArgs.orderBy.length > 0 &&
-			!objectArgs.orderBy[0]._random &&
-			objectArgs.orderBy[0]._randomSeeded === undefined
+		const hasFieldOrderBy = objectArgs.orderBy
+			&& objectArgs.orderBy.length > 0
+			&& !objectArgs.orderBy[0]._random
+			&& objectArgs.orderBy[0]._randomSeeded === undefined
 
 		if (hasWhere || hasFieldOrderBy) {
 			const path = this.pathFactory.create([])
-			qb = qb.join(targetEntity.tableName, path.alias, condition =>
-				condition.compareColumns(['junction_', column.targetColumn.columnName], Operator.eq, [
-					path.alias,
-					targetEntity.primaryColumn,
-				]),
+			qb = qb.join(
+				targetEntity.tableName,
+				path.alias,
+				condition =>
+					condition.compareColumns(['junction_', column.targetColumn.columnName], Operator.eq, [
+						path.alias,
+						targetEntity.primaryColumn,
+					]),
 			)
 		}
 

package/src/mapper/select/SelectBuilder.ts

@@ -66,7 +66,7 @@ export class SelectBuilder {
 				[path.alias, groupByColumn],
 				(orderable, qb) => {
 					if (orderBy.length > 0) {
-						[qb, orderable] = this.orderByBuilder.build(qb, orderable, entity, this.pathFactory.create([]), orderBy)
+						;[qb, orderable] = this.orderByBuilder.build(qb, orderable, entity, this.pathFactory.create([]), orderBy)
 					}
 					return [orderable, qb]
 				},
@@ -75,7 +75,7 @@ export class SelectBuilder {
 			)
 		} else {
 			if (orderBy.length > 0) {
-				[this.qb] = this.orderByBuilder.build(this.qb, null, entity, path, orderBy)
+				;[this.qb] = this.orderByBuilder.build(this.qb, null, entity, path, orderBy)
 			}
 			this.qb = this.qb.limit(input.args.limit, input.args.offset)
 		}
@@ -103,16 +103,15 @@ export class SelectBuilder {
 					entity,
 					path.back(),
 					fieldPredicate,
-					apply => this.qb.select(expr =>
-						expr.selectCondition(condition => {
-							condition = apply(condition)
-							if (condition.isEmpty()) {
-								return condition.raw('true')
-							}
-							return condition
-						}),
-					predicatePath.alias,
-					),
+					apply =>
+						this.qb.select(expr =>
+							expr.selectCondition(condition => {
+								condition = apply(condition)
+								if (condition.isEmpty()) {
+									return condition.raw('true')
+								}
+								return condition
+							}), predicatePath.alias),
 					{ relationPath: this.relationPath, evaluatedPredicates: [primaryPredicate] },
 				)
 				fetchedPredicates.add(predicate)
@@ -132,7 +131,6 @@ export class SelectBuilder {
 				return assertNever(field)
 			})()
 
-
 			const executionContext: SelectExecutionHandlerContext = {
 				mapper,
 				relationPath: this.relationPath,
@@ -198,7 +196,11 @@ export class SelectBuilder {
 		}
 	}
 
-	private async getColumnValues(columnPath: Path, columnName: string, predicateGetter: null | ColumnValueGetter<boolean>): Promise<Input.PrimaryValue[]> {
+	private async getColumnValues(
+		columnPath: Path,
+		columnName: string,
+		predicateGetter: null | ColumnValueGetter<boolean>,
+	): Promise<Input.PrimaryValue[]> {
 		this.qb = this.qb.select([columnPath.back().alias, columnName], columnPath.alias)
 		const rows = await this.rows
 		const filteredRows = predicateGetter === null ? rows : rows.filter(predicateGetter)

package/src/mapper/select/SelectExecutionHandler.ts

@@ -17,31 +17,33 @@ export type DataCallback = (ids: Input.PrimaryValue[]) => Promise<SelectNestedDa
 export type SelectExecutionHandlerContext<
 	FieldArgs = any,
 	FieldExtensions extends Record<string, any> = Record<string, any>,
-> = {
-	mapper: Mapper
-	path: Path
-	entity: Model.Entity
-	relationPath: Model.AnyRelationContext[]
-	addPredicate: (predicate: Acl.Predicate) => (row: SelectRow) => boolean
-	addColumn: (args: {
-		predicate?: Acl.Predicate
-		query?: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>
-		path?: Path
-		valueGetter?: ColumnValueGetter
-	}) => void
-	addData: (args: {
-		field: string
-		dataProvider: DataCallback
-		predicate?: Acl.Predicate
-		defaultValue?: SelectNestedDefaultValue
-	}) => void
-} & (
-	| {
-		fieldNode: FieldNode<FieldExtensions>
-		objectNode?: never
-	  }
-	| {
-		fieldNode?: never
-		objectNode: ObjectNode<FieldArgs, FieldExtensions>
-	  }
-)
+> =
+	& {
+		mapper: Mapper
+		path: Path
+		entity: Model.Entity
+		relationPath: Model.AnyRelationContext[]
+		addPredicate: (predicate: Acl.Predicate) => (row: SelectRow) => boolean
+		addColumn: (args: {
+			predicate?: Acl.Predicate
+			query?: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>
+			path?: Path
+			valueGetter?: ColumnValueGetter
+		}) => void
+		addData: (args: {
+			field: string
+			dataProvider: DataCallback
+			predicate?: Acl.Predicate
+			defaultValue?: SelectNestedDefaultValue
+		}) => void
+	}
+	& (
+		| {
+			fieldNode: FieldNode<FieldExtensions>
+			objectNode?: never
+		}
+		| {
+			fieldNode?: never
+			objectNode: ObjectNode<FieldArgs, FieldExtensions>
+		}
+	)

package/src/mapper/select/SelectHydrator.ts

@@ -90,7 +90,7 @@ export class SelectHydrator {
 		for (let { path, getParentValue, data, defaultValue } of resolvedData) {
 			const pathTmp = [...path.path]
 			const last = pathTmp.pop() as string
-			const currentObject = pathTmp.reduce<any>((obj, part) => (obj && obj[part]) || undefined, result)
+			const currentObject = pathTmp.reduce<any>((obj, part) => (obj?.[part]) || undefined, result)
 			const parentValue = getParentValue(row)
 			if (currentObject) {
 				currentObject[last] = (parentValue ? data[parentValue] : undefined) || defaultValue