@contember/engine-content-api 1.2.0-rc.4 → 1.3.0-alpha.1

package/src/mapper/relations/OneHasOneInverseCreateInputProcessor.ts

@@ -0,0 +1,99 @@
+import { InsertBuilder } from '../insert'
+import { Mapper } from '../Mapper'
+import {
+	ConstraintType,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationResultList,
+} from '../Result'
+import { CheckedPrimary } from '../CheckedPrimary'
+import { Input, Model } from '@contember/schema'
+
+export class OneHasOneInverseCreateInputProcessor {
+	constructor(
+		private readonly insertBuilder: InsertBuilder,
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(context: Model.OneHasOneInverseContext & { input: Input.UniqueWhere }) {
+		const { targetEntity, input } = context
+		const primary = await this.insertBuilder.insert
+		if (!primary) {
+			return []
+		}
+		const owner = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (!owner) {
+			return [new MutationEntryNotFoundError([], input)]
+		}
+
+		return await this.connectInternal({ ...context, input: new CheckedPrimary(owner) }, primary)
+	}
+
+
+	public async create(
+		context: Model.OneHasOneInverseContext & { input: Input.CreateDataInput },
+	) {
+		const primary = await this.insertBuilder.insert
+		if (!primary) {
+			return []
+		}
+		return await this.mapper.insert(context.targetEntity, context.input, builder => {
+			builder.addPredicates([context.targetRelation.name])
+			builder.addFieldValue(context.targetRelation.name, primary)
+		})
+	}
+
+	public async connectOrCreate(
+		{ input, ...context }: Model.OneHasOneInverseContext & { input: Input.ConnectOrCreateInput },
+	) {
+		const primary = await this.insertBuilder.insert
+		if (!primary) {
+			return []
+		}
+		const owner = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
+		if (owner) {
+			return await this.connectInternal({ ...context, input: new CheckedPrimary(owner) }, primary)
+		}
+
+		return await this.createInternal({ input: input.create, ...context }, primary)
+	}
+
+	private async connectInternal(
+		{ entity, targetEntity, targetRelation, relation, input }: Model.OneHasOneInverseContext & { input: CheckedPrimary },
+		primary: Input.PrimaryValue,
+	) {
+
+		const currentInverseSideOfOwner = await this.mapper.selectField(targetEntity, input, targetRelation.name)
+		const orphanResult: MutationResultList = []
+		if (currentInverseSideOfOwner) {
+			if (targetRelation.orphanRemoval) {
+				const orphanUnique = { [entity.primary]: currentInverseSideOfOwner }
+				const orphanDelete = await this.mapper.delete(entity, orphanUnique)
+				orphanResult.push(...orphanDelete)
+			} else if (!relation.nullable) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+		}
+
+		const connectResult = await this.mapper.updateInternal(targetEntity, input, update => {
+			update.addPredicates([targetRelation.name])
+			update.addFieldValue(targetRelation.name, primary)
+		})
+
+		return [
+			...connectResult,
+			...orphanResult,
+		]
+	}
+
+	private async createInternal(
+		context: Model.OneHasOneInverseContext & { input: Input.CreateDataInput },
+		primary: Input.PrimaryValue,
+	) {
+		return await this.mapper.insert(context.targetEntity, context.input, builder => {
+			builder.addPredicates([context.targetRelation.name])
+			builder.addFieldValue(context.targetRelation.name, primary)
+		})
+	}
+}

package/src/mapper/relations/OneHasOneInverseUpdateInputProcessor.ts

@@ -0,0 +1,164 @@
+import {
+	ConstraintType,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationNothingToDo,
+	MutationResultList,
+	MutationResultType,
+	NothingToDoReason,
+} from '../Result'
+import { UpdateInputProcessor } from '../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { Mapper } from '../Mapper'
+
+export class OneHasOneInverseUpdateInputProcessor {
+	constructor(
+		private readonly primaryValue: Input.PrimaryValue,
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere }) {
+		const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
+		if (!newOwner) {
+			return [new MutationEntryNotFoundError([], input)]
+		}
+		return await this.connectInternal(ctx, newOwner)
+	}
+
+	public async connectOrCreate(
+		{ input, ...ctx }: Model.OneHasOneInverseContext & { input: Input.ConnectOrCreateInput },
+	) {
+		const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input.connect)
+		if (newOwner) {
+			return await this.connectInternal(ctx, newOwner)
+		}
+		return await this.create({ ...ctx, input: input.create })
+	}
+
+
+	private async connectInternal(
+		{ entity, targetEntity, targetRelation }: Model.OneHasOneInverseContext,
+		newOwner: Input.PrimaryValue,
+	) {
+		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
+			[targetRelation.name]: { [entity.primary]: this.primaryValue },
+		})
+		if (newOwner === currentOwner) {
+			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
+		}
+		const result: MutationResultList = []
+		if (currentOwner) {
+			if (!targetRelation.nullable) {
+				// todo cascade delete support?
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: currentOwner }, builder => {
+				builder.addPredicates([targetRelation.name])
+				builder.addFieldValue(targetRelation.name, null)
+			})
+			result.push(...disconnectFromCurrentOwner)
+		}
+		const orphanedInverseSide = targetRelation.orphanRemoval
+			? await this.mapper.selectField(targetEntity, { [targetEntity.primary]: newOwner }, targetRelation.name)
+			: null
+
+		const connectToNewOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: newOwner }, builder => {
+			builder.addPredicates([targetRelation.name])
+			builder.addFieldValue(targetRelation.name, this.primaryValue)
+		})
+		result.push(...connectToNewOwner)
+
+		if (orphanedInverseSide) {
+			const deleteOrphanedInverseSide = await this.mapper.delete(entity, { [entity.primary]: orphanedInverseSide })
+			result.push(...deleteOrphanedInverseSide)
+		}
+		return result
+	}
+
+	public async create({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.CreateDataInput }) {
+		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
+			[targetRelation.name]: { [entity.primary]: this.primaryValue },
+		})
+		if (currentOwner && !targetRelation.nullable) {
+			// todo cascade delete support?
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		const result: MutationResultList = []
+		if (currentOwner) {
+			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: currentOwner }, builder => {
+				builder.addPredicates([targetRelation.name])
+				builder.addFieldValue(targetRelation.name, null)
+			})
+			result.push(...disconnectFromCurrentOwner)
+		}
+
+		const connectToNewlyCreatedOwner = await this.mapper.insert(targetEntity, input, builder => {
+			builder.addFieldValue(targetRelation.name, this.primaryValue)
+			builder.addPredicates([targetRelation.name])
+		})
+		result.push(...connectToNewlyCreatedOwner)
+
+		return result
+	}
+
+	public async update({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.UpdateDataInput }) {
+		return await this.mapper.update(
+			targetEntity,
+			{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
+			input,
+		)
+	}
+
+	public async upsert(context: Model.OneHasOneInverseContext & { input: UpdateInputProcessor.UpsertInput }) {
+		const { targetEntity, targetRelation, entity, input: { update, create } } = context
+		const result = await this.mapper.update(
+			targetEntity,
+			{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
+			update,
+		)
+		if (result[0].result === MutationResultType.notFoundError) {
+			return await this.create({
+				...context,
+				input: create,
+			})
+		}
+		return result
+	}
+
+	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
+		if (!relation.nullable && !targetRelation.orphanRemoval) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
+			[targetRelation.name]: { [entity.primary]: this.primaryValue },
+		})
+		if (!currentOwner) {
+			return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+		}
+		if (currentOwner && !targetRelation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		const result = await this.mapper.updateInternal(
+			targetEntity,
+			{ [targetEntity.primary]: currentOwner },
+			builder => {
+				builder.addPredicates([targetRelation.name])
+				builder.addFieldValue(targetRelation.name, null)
+			},
+		)
+		if (targetRelation.orphanRemoval) {
+			result.push(...(await this.mapper.delete(entity, { [entity.primary]: this.primaryValue })))
+		}
+		return result
+	}
+
+	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
+		if (!relation.nullable && !targetRelation.orphanRemoval) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		// orphan removal is handled in mapper.delete
+		return await this.mapper.delete(targetEntity, { [targetRelation.name]: { [entity.primary]: this.primaryValue } })
+	}
+}

package/src/mapper/relations/OneHasOneOwningCreateInputProcessor.ts

@@ -0,0 +1,92 @@
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationResultList,
+} from '../Result'
+import { InsertBuilder } from '../insert'
+import { Mapper } from '../Mapper'
+import { Input, Model } from '@contember/schema'
+import { AbortDataManipulation } from '../DataManipulationBuilder'
+
+export class OneHasOneOwningCreateInputProcessor {
+	constructor(
+		private readonly insertBuilder: InsertBuilder,
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(context: Model.OneHasOneOwningContext & { input: Input.UniqueWhere }) {
+		const { input, relation, targetEntity } = context
+		const result: MutationResultList = []
+		await this.insertBuilder.addFieldValue(relation.name, async () => {
+			const inverseSide = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (!inverseSide) {
+				result.push(new MutationEntryNotFoundError([], input))
+				return AbortDataManipulation
+			}
+			return this.connectInternal({ ...context, input: inverseSide }, result)
+		})
+		return result
+	}
+
+	public async create(context: Model.OneHasOneOwningContext & { input: Input.CreateDataInput }) {
+		const result: MutationResultList = []
+		await this.insertBuilder.addFieldValue(context.relation.name, async () => {
+			return await this.createInternal(context, result)
+		})
+		return result
+	}
+
+	public async connectOrCreate({ input, ...context }: Model.OneHasOneOwningContext & { input: Input.ConnectOrCreateInput }) {
+		const result: MutationResultList = []
+		await this.insertBuilder.addFieldValue(context.relation.name, async () => {
+			const inverseSide = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
+			if (inverseSide) {
+				return await this.connectInternal({ ...context, input: inverseSide }, result)
+			}
+			return await this.createInternal({ ...context, input: input.create }, result)
+		})
+		return result
+	}
+
+	private async createInternal(
+		context: Model.OneHasOneOwningContext & { input: Input.CreateDataInput },
+		result: MutationResultList,
+	) {
+		const insertResult = await this.mapper.insert(context.targetEntity, context.input)
+		result.push(...insertResult)
+		const primary = getInsertPrimary(insertResult)
+		if (!primary) {
+			return AbortDataManipulation
+		}
+		return primary
+	}
+
+	private async connectInternal(
+		{ entity, relation, targetEntity, input }: Model.OneHasOneOwningContext & { input: Input.PrimaryValue },
+		result: MutationResultList,
+	) {
+		const currentOwnerOfInverseSide = await this.mapper.getPrimaryValue(entity, {
+			[relation.name]: { [targetEntity.primary]: input },
+		})
+		if (!currentOwnerOfInverseSide) {
+			return input
+		}
+
+		if (!relation.nullable) {
+			result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
+			return AbortDataManipulation
+		}
+
+		const currentOwnerUnique = { [entity.primary]: currentOwnerOfInverseSide }
+		const currentOwnerDisconnectResult = await this.mapper.updateInternal(entity, currentOwnerUnique, builder => {
+			builder.addPredicates([relation.name])
+			builder.addFieldValue(relation.name, null)
+		})
+		result.push(...currentOwnerDisconnectResult)
+
+		return input
+	}
+}

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