@contember/engine-content-api 1.2.1 → 1.3.0-alpha.13

package/src/mapper/relations/OneHasOneOwningUpdateInputProcessor.ts

@@ -0,0 +1,253 @@
+import { UpdateInputProcessor } from '../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationNothingToDo,
+	MutationResultList,
+	NothingToDoReason,
+} from '../Result'
+import { Mapper } from '../Mapper'
+import { UpdateBuilder } from '../update/UpdateBuilder'
+import { CheckedPrimary } from '../CheckedPrimary'
+import { AbortDataManipulation } from '../DataManipulationBuilder'
+
+export class OneHasOneOwningUpdateInputProcessor {
+	constructor(
+		private readonly primaryValue: Input.PrimaryValue,
+		private readonly mapper: Mapper,
+		private readonly updateBuilder: UpdateBuilder,
+	) {
+	}
+
+	public async connect(context: Model.OneHasOneOwningContext & { input: Input.UniqueWhere }) {
+		const result: MutationResultList = []
+		let currentInverseSide: Input.PrimaryValue | undefined
+
+		const { entity, relation, targetEntity, targetRelation, input } = context
+		const newInverseSide = await this.updateBuilder.addFieldValue(relation.name, async () => {
+			const newInverseSide = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (!newInverseSide) {
+				result.push(new MutationEntryNotFoundError([], input))
+				return AbortDataManipulation
+			}
+			currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+			return await this.connectInternal(context, currentInverseSide, newInverseSide, result)
+		})
+
+		if (newInverseSide) {
+			result.push(...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)))
+		}
+
+		return result
+	}
+
+	public async create(context: Model.OneHasOneOwningContext & { input: Input.CreateDataInput }) {
+		const result: MutationResultList = []
+		let currentInverseSide: Input.PrimaryValue | undefined
+		const { entity, relation, targetEntity, targetRelation } = context
+		await this.updateBuilder.addFieldValue(relation.name, async () => {
+			currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+			// orphan removal handled bellow
+			return await this.createInternal(context, currentInverseSide, result)
+		})
+
+		result.push(...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)))
+		return result
+	}
+
+	public async connectOrCreate({ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: Input.ConnectOrCreateInput }) {
+		const result: MutationResultList = []
+		let currentInverseSide: Input.PrimaryValue | undefined
+
+		const { relation, targetRelation, targetEntity, entity } = context
+		const newInverseSide = await this.updateBuilder.addFieldValue(relation.name, async () => {
+			const newInverseSide = await this.mapper.getPrimaryValue(targetEntity, connect)
+			currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+			if (newInverseSide) {
+				return await this.connectInternal(context, currentInverseSide, newInverseSide, result)
+			}
+			return await this.createInternal({ ...context, input: create }, currentInverseSide, result)
+		})
+
+		if (newInverseSide) {
+			result.push(...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)))
+		}
+
+		return result
+	}
+
+	private async createInternal(
+		{ targetEntity, targetRelation, relation, input }: Model.OneHasOneOwningContext & { input: Input.CreateDataInput },
+		currentInverseSide: Input.PrimaryValue | undefined,
+		result: MutationResultList,
+	) {
+		if (targetRelation && !targetRelation.nullable && !relation.orphanRemoval && currentInverseSide) {
+			result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
+			return AbortDataManipulation
+		}
+
+		const insertResult = await this.mapper.insert(targetEntity, input)
+		result.push(...insertResult)
+		const newInverseSide = getInsertPrimary(insertResult)
+		if (newInverseSide) {
+			return newInverseSide
+		}
+		return AbortDataManipulation
+	}
+
+	private async connectInternal(
+		{ targetEntity, targetRelation, relation, entity }: Model.OneHasOneOwningContext,
+		currentInverseSide: Input.PrimaryValue | undefined,
+		newInverseSide: Input.PrimaryValue,
+		result: MutationResultList,
+	) {
+
+		if (currentInverseSide === newInverseSide) {
+			result.push(new MutationNothingToDo([], NothingToDoReason.alreadyExists))
+			return undefined
+		}
+
+		const currentOwnerOfNewInverseSide = await this.mapper.getPrimaryValue(entity, {
+			[relation.name]: { [targetEntity.primary]: newInverseSide },
+		})
+
+		if (currentOwnerOfNewInverseSide === this.primaryValue) {
+			result.push(new MutationNothingToDo([], NothingToDoReason.alreadyExists))
+			return undefined
+		}
+
+		// orphan removal handled bellow
+		if (targetRelation && !targetRelation.nullable && !relation.orphanRemoval && currentInverseSide) {
+			result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
+			return AbortDataManipulation
+		}
+
+		if (currentOwnerOfNewInverseSide) {
+			if (!relation.nullable) {
+				result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
+				return AbortDataManipulation
+			}
+
+			const currentOwnerDisconnect = await this.mapper.updateInternal(
+				entity,
+				{
+					[entity.primary]: currentOwnerOfNewInverseSide,
+				},
+				builder => {
+					builder.addPredicates([relation.name])
+					builder.addFieldValue(relation.name, null)
+				},
+			)
+			result.push(...currentOwnerDisconnect)
+		}
+		return newInverseSide
+	}
+
+	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) {
+		if (relation.orphanRemoval && currentInverseSide) {
+			await this.updateBuilder.update
+			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: currentInverseSide })
+		}
+		return []
+	}
+
+	public async update({ entity, relation, targetEntity, input }: Model.OneHasOneOwningContext & { input: Input.UpdateDataInput }) {
+		const inversePrimary = await this.mapper.selectField(
+			entity,
+			{ [entity.primary]: this.primaryValue },
+			relation.name,
+		)
+		if (!inversePrimary) {
+			return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+		}
+		return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, input)
+	}
+
+	public async upsert({ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput }) {
+		const select = this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
+
+		const result: MutationResultList = []
+		//addColumnData has to be called synchronously
+		await this.updateBuilder.addFieldValue(relation.name, async () => {
+			const primary = await select
+			if (primary) {
+				return undefined
+			}
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const insertPrimary = getInsertPrimary(insertResult)
+			if (insertPrimary) {
+				return insertPrimary
+			}
+			result.push(...insertResult)
+			return AbortDataManipulation
+		})
+
+		const inversePrimary = await select
+		if (inversePrimary) {
+			return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, update)
+		}
+		return result
+	}
+
+	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneOwningContext & { input: undefined }) {
+		if (!relation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		const result: MutationResultList = []
+
+		const currentInverseSide = (targetRelation && !targetRelation.nullable) || relation.orphanRemoval
+			? this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
+			: Promise.resolve(undefined)
+
+		this.updateBuilder.addFieldValue(relation.name, async () => {
+			const inversePrimary = await currentInverseSide
+			if (inversePrimary && targetRelation && !targetRelation.nullable && !relation.orphanRemoval) {
+				result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
+				return AbortDataManipulation
+			}
+			return null
+		})
+		if (relation.orphanRemoval) {
+			const inversePrimary = await currentInverseSide
+			if (inversePrimary) {
+				await this.updateBuilder.update
+				const deleteOrphanedInverseSide = await this.mapper.delete(targetEntity, { [targetEntity.primary]: inversePrimary })
+				result.push(...deleteOrphanedInverseSide)
+			}
+		}
+		return result
+	}
+
+	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneOwningContext & { input: undefined }) {
+		if (!relation.nullable && relation.joiningColumn.onDelete !== Model.OnDelete.cascade) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
+			// eslint-disable-next-line no-console
+			console.error(
+				'[DEPRECATED] You are deleting an entity over the relation where onDelete behaviour is set to restrict. This will fail in next version.',
+			)
+			this.updateBuilder.addFieldValue(relation.name, null)
+		}
+		const targetPrimary = await this.mapper.selectField(
+			entity,
+			{ [entity.primary]: this.primaryValue },
+			relation.name,
+		)
+		if (!targetPrimary) {
+			return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+		}
+		await this.updateBuilder.update
+		return await this.mapper.delete(targetEntity, new CheckedPrimary(targetPrimary))
+	}
+}

package/src/mapper/select/JoinBuilder.ts

@@ -8,12 +8,12 @@ import { SelectBuilder } from '@contember/database'
 export class JoinBuilder {
 	constructor(private readonly schema: Model.Schema) {}
 
-	join<Filled extends keyof SelectBuilder.Options>(
-		qb: SelectBuilder<SelectBuilder.Result>,
+	join<R extends SelectBuilder.Result>(
+		qb: SelectBuilder<R>,
 		path: Path,
 		entity: Model.Entity,
 		relationName: string,
-	) {
+	): SelectBuilder<R> {
 		const targetEntity = getTargetEntity(this.schema, entity, relationName)
 		if (!targetEntity) {
 			throw new Error(`JoinBuilder: target entity for relation ${entity.name}::${relationName} not found`)
@@ -21,7 +21,7 @@ export class JoinBuilder {
 
 		const joins = acceptRelationTypeVisitor(this.schema, entity, relationName, new JoinVisitor(path))
 
-		return joins.reduce<SelectBuilder<SelectBuilder.Result>>((qb, join) => {
+		return joins.reduce<SelectBuilder<R>>((qb, join) => {
 			const targetAlias = join.targetAlias || path.alias
 			if (qb.options.join.find(it => it.alias === targetAlias)) {
 				return qb

package/src/mapper/select/OrderByHelper.ts

@@ -5,10 +5,11 @@ export class OrderByHelper {
 	public static appendDefaultOrderBy(
 		entity: Model.Entity,
 		objectNode: ObjectNode<Input.ListQueryInput>,
-		defaultOrderBy: readonly Model.OrderBy[],
+		relationOrderBy: readonly Model.OrderBy[] | undefined,
 	): ObjectNode<Input.ListQueryInput> {
 		const inputOrder = objectNode.args.orderBy || []
 		const hasOrderBy = inputOrder.length > 0
+		const defaultOrderBy = relationOrderBy ?? entity.orderBy ?? []
 		if (!hasOrderBy && defaultOrderBy.length > 0) {
 			const defaultOrderByWithPrimary = [...defaultOrderBy, ...this.getPrimaryOrderBy(inputOrder, entity)]
 			return objectNode.withArg('orderBy', this.buildOrderBy(defaultOrderByWithPrimary))

package/src/mapper/select/RelationFetcher.ts

@@ -83,7 +83,7 @@ export class RelationFetcher {
 		const objectNodeWithOrder = OrderByHelper.appendDefaultOrderBy(
 			targetEntity,
 			objectNodeWithWhere,
-			relation.orderBy || [],
+			relation.orderBy,
 		)
 
 		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation, [
@@ -144,7 +144,7 @@ export class RelationFetcher {
 	}: FetchManyHasManyGroupsArgs): Promise<SelectGroupedObjects> {
 		const owningRelation = relationContext.type === 'manyHasManyInverse' ? relationContext.targetRelation : relationContext.relation
 		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
-		const defaultOrderBy = relationContext.relation.orderBy || []
+		const defaultOrderBy = relationContext.relation.orderBy
 		const objectNode = OrderByHelper.appendDefaultOrderBy(relationContext.targetEntity, field, defaultOrderBy)
 		const { targetEntity } = relationContext
 		const junctionValues = await this.fetchJunction(

package/src/mapper/select/WhereBuilder.ts

@@ -23,13 +23,13 @@ export class WhereBuilder {
 		private readonly useExistsInHasManyFilter: boolean,
 	) {}
 
-	public build(
-		qb: SelectBuilder<SelectBuilder.Result>,
+	public build<R extends SelectBuilder.Result>(
+		qb: SelectBuilder<R>,
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
 		optimizationHints: WhereOptimizationHints = {},
-	) {
+	): SelectBuilder<R> {
 		const optimizedWhere = this.whereOptimizer.optimize(where, entity, optimizationHints)
 		return this.buildInternal({
 			entity,
@@ -41,13 +41,13 @@ export class WhereBuilder {
 	}
 
 
-	public buildAdvanced(
+	public buildAdvanced<R extends SelectBuilder.Result>(
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
-		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
+		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<R>,
 		optimizationHints: WhereOptimizationHints = {},
-	) {
+	): SelectBuilder<R> {
 		const optimizedWhere = this.whereOptimizer.optimize(where, entity, optimizationHints)
 		return this.buildInternal({
 			entity,
@@ -58,11 +58,11 @@ export class WhereBuilder {
 		})
 	}
 
-	private buildInternal({
+	private buildInternal<R extends SelectBuilder.Result>({
 		callback,
 		...args
-	}: { entity: Model.Entity; path: Path; where: Input.OptionalWhere; callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>; allowManyJoin: boolean },
-	) {
+	}: { entity: Model.Entity; path: Path; where: Input.OptionalWhere; callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<R>; allowManyJoin: boolean },
+	): SelectBuilder<R> {
 		const joinList: WhereJoinDefinition[] = []
 
 		const qbWithWhere = callback(clause => this.buildRecursive({
@@ -70,8 +70,8 @@ export class WhereBuilder {
 			joinList: joinList,
 			...args,
 		}))
-		return joinList.reduce<SelectBuilder<SelectBuilder.Result>>(
-			(qb, { path, entity, relationName }) => this.joinBuilder.join(qb, path, entity, relationName),
+		return joinList.reduce<SelectBuilder<R>>(
+			(qb, { path, entity, relationName }) => this.joinBuilder.join<R>(qb, path, entity, relationName),
 			qbWithWhere,
 		)
 	}