How to update an entity with relations using QueryBuilder in TypeORM

Using QueryBuilder in TypeORM to update entities with relationships is an advanced operation that requires a solid understanding of relationship management in TypeORM and QueryBuilder usage. Below, I will demonstrate how to perform this operation with a specific example.

Assume we have two entities: User and Profile. There is a one-to-one relationship between the User entity and the Profile entity. The User entity is defined as follows:

typescript
import { Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn } from "typeorm";
import { Profile } from "./Profile";

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    @OneToOne(() => Profile, profile => profile.user)
    @JoinColumn()
    profile: Profile;
}

The Profile entity is defined as follows:

typescript
import { Entity, PrimaryGeneratedColumn, Column, OneToOne } from "typeorm";
import { User } from "./User";

@Entity()
export class Profile {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    age: number;

    @OneToOne(() => User, user => user.profile)
    user: User;
}

Now, assume we want to update a user's name and age. First, we need to load the user and their profile, then update them. Here is how to achieve this using QueryBuilder:

typescript
import { getConnection } from "typeorm";

async function updateUserAndProfile(userId: number, newName: string, newAge: number) {
    const connection = getConnection();
    const queryRunner = connection.createQueryRunner();

    await queryRunner.connect();
    await queryRunner.startTransaction();

    try {
        // Update the user's name
        await queryRunner.manager
            .createQueryBuilder()
            .update(User)
            .set({ name: newName })
            .where("id = :id", { id: userId })
            .execute();

        // Update the profile's age
        await queryRunner.manager
            .createQueryBuilder()
            .update(Profile)
            .set({ age: newAge })
            .where("userId = :userId", { userId: userId })
            .execute();

        await queryRunner.commitTransaction();
    } catch (err) {
        // If an error occurs, roll back the transaction
        await queryRunner.rollbackTransaction();
        throw err;
    } finally {
        // Release the query runner
        await queryRunner.release();
    }
}

In this example, we first create a query runner to manage transactions. We update the user's name and the profile's age separately. Note that we use userId as the condition for updating the Profile, as there is a foreign key userId in the Profile entity pointing to the User entity.

Ensure that transactions are properly handled during operations to maintain data consistency. If any errors occur during the update, we roll back the transaction to avoid issues caused by partial updates.

This is a simple example; in real applications, you may need to handle more complex relationships and additional details.