TypeORM Entity metadata for Some#other was not found. Check if you specified a correct entity object and if it’s connected in the connection options

Im having an issue and i have read almost all other active issues on this topic. Im trying to make a custom ManyToMany mapping table as per the TypeORM docs using a seperate entity:

Mapping entity:

import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
import { Driver } from './driver.entity';
import { RegistrationStatus } from '../utils/enums';
import { EntityHelper } from './base/entity-helper';
import { Car } from './car.entity';

@Entity()
export class DriverCarsAndStatus extends EntityHelper {
  @ManyToOne(() => Driver)
  @JoinColumn()
  driver: Driver;

  @ManyToOne(() => Car)
  @JoinColumn()
  car: Car;

  @Column({
    type: 'enum',
    enum: RegistrationStatus,
    default: RegistrationStatus.PENDING,
  })
  status: RegistrationStatus;
}

Driver entity:

import { Exclude, Expose } from 'class-transformer';
import {
  AfterLoad,
  BeforeInsert,
  BeforeUpdate,
  Column,
  Entity,
  Index,
  JoinColumn,
  ManyToOne,
  OneToMany,
  OneToOne,
} from 'typeorm';
import * as bcrypt from 'bcryptjs';
import { IsNumber, IsOptional, Max, Min } from 'class-validator';
import { DriverReview } from './driver-reviews.entity';
import { UserReview } from './user-reviews.entity';
import { RequestedDriver } from './requestedDriver.entity';
import {
  AuthProvidersEnum,
  OperationalStatus,
  RegistrationStatus,
} from '../utils/enums';
import { MainEntity } from './base/main-entity';
import { Car } from '@app/shared/entities/car.entity';
import { Trip } from './trip.entity';
import { Emergency } from './emergency.entity';
import { Role } from './role.entity';
import { Document } from '@app/shared/entities/document.entity';
import { DocumentType } from '../utils/enums';
import { Address } from './address.entity';
import { DriverCarsAndStatus } from './driverCarsStatuses.entity';

@Entity()
export class Driver extends MainEntity {
  @Column({ type: String, unique: true, nullable: true })
  // @Expose({ groups: ['me', 'admin'] })
  email: string;

  @Column({ nullable: true })
  @Exclude({ toPlainOnly: true })
  password: string;

  @Exclude({ toPlainOnly: true })
  public previousPassword: string;

  @Index()
  @Column({ type: String, nullable: true })
  firstName?: string;

  @Index()
  @Column({ type: String, nullable: true })
  lastName?: string;

  @Column({ type: String, nullable: true })
  phoneCode: string;

  @Column({ type: String, nullable: true })
  phoneNumber: string;

  @Column({ type: String, nullable: true })
  countryCode: string;

  @IsNumber({ maxDecimalPlaces: 1 })
  @Max(5)
  @Min(1)
  @Column({ type: 'float', default: 5 })
  rating: number;

  @Column({ type: 'date', nullable: true })
  birthDate: Date;

  @Column({ nullable: true })
  nationalId?: string;

  @Column({
    type: 'enum',
    enum: RegistrationStatus,
    default: RegistrationStatus.PENDING,
  })
  registrationStatus: RegistrationStatus;

  @Column({
    type: 'enum',
    enum: OperationalStatus,
    default: OperationalStatus.ACTIVATED,
  })
  operationalStatus: OperationalStatus;

  @Column({ type: 'decimal', nullable: true })
  totalCashFlow: number;

  @Column({ type: 'decimal', nullable: true })
  totalTaxes: number;

  @Column({ type: 'decimal', nullable: true })
  totalEarnings: number;

  @Column({ type: 'decimal', nullable: true })
  moneyInWallet: number;

  @Column({ nullable: true })
  employeeNumber: number;

  @Column({ nullable: true })
  statusReason: string;

  @OneToMany(() => Trip, (trip) => trip.driver)
  @JoinColumn({ name: 'driverId' })
  trips: Trip[];

  @ManyToOne(() => Role, {
    eager: true,
  })
  role?: Role;

  // @OneToMany(
  //   () => DriverCarsAndStatus,
  //   (driverCarStatus) => driverCarStatus.driver,
  // )
  // driverCarStatuses: DriverCarsAndStatus[];

  @Column({ default: AuthProvidersEnum.email })
  @Expose({ groups: ['me', 'admin'] })
  provider: string;

  @Index()
  @Column({ type: String, nullable: true })
  @Expose({ groups: ['me', 'admin'] })
  socialId: string | null;

  @OneToMany(() => Document, (document) => document.driver, {
    nullable: true,
  })
  @IsOptional()
  @JoinColumn()
  documents: Document[] | null;

  @Column({
    type: 'jsonb',
    nullable: true,
    default: () => "'{}'",
  })
  declinedDocuments: Record<DocumentType, boolean>;

  @ManyToOne(() => Address, { nullable: true })
  address: Address;

  @OneToOne(() => Car, (car) => car.currentDriver)
  @JoinColumn()
  currentCar: Car | null;

  @OneToMany(() => DriverReview, (driverReview) => driverReview.author)
  authoredReviews: DriverReview[];

  @OneToMany(() => UserReview, (userReview) => userReview.targetDriver)
  receivedReviews: UserReview[];

  @OneToMany(() => Emergency, (emergency) => emergency.driver)
  emergencies: Promise<Emergency[]>;

  @OneToMany(() => RequestedDriver, (requestedDriver) => requestedDriver.driver)
  requestedDrivers: RequestedDriver[];

  @AfterLoad()
  public loadPreviousPassword(): void {
    this.previousPassword = this.password;
  }
  @BeforeInsert()
  @BeforeUpdate()
  async setPassword() {
    if (this.previousPassword !== this.password && this.password) {
      const salt = await bcrypt.genSalt();
      this.password = await bcrypt.hash(this.password, salt);
    }
  }
}

Car entity:

import {
  Entity,
  Column,
  JoinColumn,
  ManyToOne,
  OneToOne,
  OneToMany,
} from 'typeorm';
import {
  CarClass,
  OperationalStatus,
  RegistrationStatus,
} from '../utils/enums';
import { Make } from './make.entity';
import { Model } from './model.entity';
import { MainEntity } from './base/main-entity';
import { Driver } from '@app/shared/entities/driver.entity';
import { Trip } from './trip.entity';
import { Document } from './document.entity';
import { DriverCarsAndStatus } from './driverCarsStatuses.entity';
@Entity()
export class Car extends MainEntity {
  @Column()
  plateNumber: string;

  @Column()
  color: string;

  @ManyToOne(() => Make, (make) => make.car)
  @JoinColumn()
  make: Make;

  @ManyToOne(() => Model, (model) => model.car)
  @JoinColumn()
  model: Model;

  @Column({ type: 'int' })
  yearOfProduction: number;

  @Column({
    type: 'enum',
    enum: CarClass,
  })
  carClass: CarClass;

  @Column({ nullable: true })
  taxiNumber: number;

  @Column({
    type: 'enum',
    enum: OperationalStatus,
    nullable: true,
  })
  operationalStatus: OperationalStatus;

  @Column({ type: 'enum', enum: RegistrationStatus })
  registrationStatus: RegistrationStatus;

  // @OneToMany(
  //   () => DriverCarsAndStatus,
  //   (driverCarStatus) => driverCarStatus.car,
  // )
  // driverCarStatuses: DriverCarsAndStatus[];

  @OneToMany(() => Document, (document) => document.car)
  carDocuments: Document[];

  @OneToOne(() => Driver, (driver) => driver.currentCar)
  currentDriver: Driver | null;

  @OneToMany(() => Trip, (trip) => trip.car, { nullable: true })
  @JoinColumn({ name: 'carId' })
  trips: Trip[];
}

I have the file name specified correctly:
driverCarAndStatuses.entity.ts as per the typeORM config file:

entities: [__dirname + '/../**/*.entity{.ts,.js}'],
      migrations: [__dirname + '/migrations/**/*{.ts,.js}'],
      cli: {
        entitiesDir: 'src',
        migrationsDir: 'src/database/migrations',
        subscribersDir: 'subscriber',
      },

And whenever if codeout the OneToMany decorators from either Driver or Car entity to make it bi-directional as needed I get the error:
[Nest] 26396 – 08/01/2024, 4:14:55 PM ERROR [TypeOrmModule] Unable to connect to the database. Retrying (1)…
[3] TypeORMError: Entity metadata for Driver#driverCarStatuses was not found. Check if you specified a correct entity object and if it’s connected in the connection options.

Everything i have tried for this issue:
Drop schema and dist folder after changes, double check file names and imports (everything is the same as others), autoLoadEntities in orm config, checked
“emitDecoratorMetadata”: true,
“experimentalDecorators”: true,
for tsconfig,
added Entity DriverCarAndStatus in TypeORM.forFeatur in both Driver and Car modules.