How to query entity based on relation property in TypeORM

When using TypeORM, querying entities based on relationship properties is a common and powerful feature that enables us to retrieve associated data. I'll demonstrate this with an example.

Assume we have two entities, User and Photo, which have a one-to-many relationship. That is, a user can have multiple photos. The definitions of the User and Photo entities might be as follows:

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

    @Column()
    name: string;

    @OneToMany(() => Photo, photo => photo.user)
    photos: Photo[];
}

@Entity()
class Photo {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    url: string;

    @ManyToOne(() => User, user => user.photos)
    user: User;
}

Now, if we want to query all users named 'John Doe' along with their photos, we can use TypeORM's query builder to achieve this. Here is the specific implementation:

typescript
import { getRepository } from "typeorm";

async function findUserWithPhotos() {
    const userRepository = getRepository(User);
    const users = await userRepository.find({
        where: { name: "John Doe" },
        relations: ["photos"]
    });

    return users;
}

In this example, we specify the relationship to load using the relations option of the find method. This instructs TypeORM to load not only the User entity but also the associated Photo entities.

The benefit is that we can retrieve user information along with their associated photos in a single operation, reducing the need for multiple database queries and significantly improving efficiency.

In addition to using the find method, we can use the more powerful QueryBuilder to construct more complex queries. For example:

typescript
const users = await getRepository(User)
    .createQueryBuilder("user")
    .leftJoinAndSelect("user.photos", "photo")
    .where("user.name = :name", { name: "John Doe" })
    .getMany();

Here, using QueryBuilder provides greater flexibility, such as adding more complex conditions, sorting, grouping, and other advanced operations.

Through these methods, TypeORM offers an efficient and intuitive approach to handling relationship-based data queries, greatly simplifying complex database operations.