TypeORM find where with an OR condition

[frail river]

Hello

I have a problem executing a certain find with two entities.
I have a job.entity

import { JobStatus } from '../../../common/enums';
import { RequirementEntity } from './requirement.entity';

const BaseEntityWithFeatures = AddDeleted(AddTimeStamps(AddUuid(EmptyEntity)));

@Entity({ name: 'job' })
export class JobEntity extends BaseEntityWithFeatures {
  @Column()
  ref: string;

  @Column()
  title: string;

  @Column()
  description: string;

  @Column()
  location: string;

  @Column()
  deadline: Date;

  @Column({ enum: JobStatus })
  status: string;

  // @OneToMany(
  //   () => ShortlistedCandidate,
  //   (shortlistedCandidate) => shortlistedCandidate.job,
  // )
  // shortlistedCandidates: ShortlistedCandidate[];

  @OneToMany(() => RequirementEntity, (requirement) => requirement.job)
  requirements: RequirementEntity[];
}

And a requirement entity

import { Column, Entity, ManyToOne } from 'typeorm';
import {
  AddDeleted,
  AddTimeStamps,
  AddUuid,
  EmptyEntity,
} from '../../../common/base-components/entities';
import { RequirementImportanceLevel } from '../../../common/enums';
import { JobEntity } from './job.entity';

const BaseEntityWithFeatures = AddDeleted(AddTimeStamps(AddUuid(EmptyEntity)));

@Entity({ name: 'requirement' })
export class RequirementEntity extends BaseEntityWithFeatures {
  @Column()
  type: string;

  @Column({ enum: RequirementImportanceLevel })
  importance: string;

  @Column()
  requirement: string;

  @ManyToOne(() => JobEntity, (job) => job.requirements)
  job: JobEntity;

  // @OneToMany(
  //   () => RequirementMatching,
  //   (requirementMatching) => requirementMatching.requirement,
  // )
  // requirementMatchings: RequirementMatching[];
}

I tried executing this method from my service:

 async findTest() {
    const values = await this.jobRepository.find({
      relations: {
        requirements: true,
      },
      where: [
        { requirements: null },
        {
          requirements: {
            deleted: false,
          },
        },
      ],
    });

    console.log('findTest :>> ' + JSON.stringify(values));
  }

I'm trying to get list of jobs with its relationship with requirements and populate requirements array if the requirements have "deleted" set to false.
What am I doing wrong?

For context, here's the base.entity file

import {
  Column,
  CreateDateColumn,
  PrimaryGeneratedColumn,
  UpdateDateColumn,
} from 'typeorm';
import { AnyConstructor, BaseConstructor } from '../constructors';

export class EmptyEntity {}

export function AddUuid<T extends AnyConstructor>(Base: T) {
  class AbstractUuid extends (Base as BaseConstructor) {
    @PrimaryGeneratedColumn('uuid')
    id: string;
  }
  return AbstractUuid;
}

export function AddTimeStamps<T extends AnyConstructor>(Base: T) {
  class AbstractTimeStamps extends (Base as BaseConstructor) {
    @CreateDateColumn()
    createdAt: Date;

    @UpdateDateColumn()
    updatedAt: Date;
  }
  return AbstractTimeStamps;
}

export function AddUserId<T extends AnyConstructor>(Base: T) {
  class AbstractUserId extends (Base as BaseConstructor) {
    @Column()
    userId: string;
  }
  return AbstractUserId;
}

export function AddNullableUserId<T extends AnyConstructor>(Base: T) {
  class AbstractNullableUserId extends (Base as BaseConstructor) {
    @Column({ nullable: true })
    userId: string;
  }
  return AbstractNullableUserId;
}

export function AddDeleted<T extends AnyConstructor>(Base: T) {
  abstract class AbstractDeleted extends (Base as BaseConstructor) {
    @Column({ type: 'boolean', default: false, select: false })
    deleted: boolean;
  }
  return AbstractDeleted;
}

export function AddArchived<T extends AnyConstructor>(Base: T) {
  class AbstractArchived extends (Base as BaseConstructor) {
    @Column({ type: 'boolean', default: false })
    archived: boolean;
  }
  return AbstractArchived;
}

export function AddEnabled<T extends AnyConstructor>(Base: T) {
  class AbstractEnabled extends (Base as BaseConstructor) {
    @Column({ type: 'boolean', default: false })
    enabled: boolean;
  }
  return AbstractEnabled;
}