typescript : clean code remove or decrease alot if's

Hello I have the following code, where I need to do many checks of calls from the database,

My TypeEnum:

export enum ProductTypes {
  equipament = 'equipament',
  component = 'component',
}

this is my use case class:

export class AssignProductUseCase
  implements
    IUseCase<AssignProductDTO, Promise<Either<AppError, ProductInstance>>> {
  constructor(
    @inject(EmployeeRepository)
    private employeeRepository: IEmployeeRepository,
    @inject(ProductRepository)
    private productRepository: IProductRepository,
    @inject(ProductInstanceRepository)
    private instanceRepository: IProductInstanceRepository,
    @inject(ProductStocksRepository)
    private stockRepository: IProductStocksRepository,
  ) {}
  public execute = async ({
    contract_id,
    matricula,
    parent_id,
    patrimony_code,
    product_id,
    serial_number,
    type,
  }: AssignProductDTO): Promise<Either<AppError, ProductInstance>> => {
    //verify type
    if (!(type in ProductTypes)) throw new Error(`${type}, is invalid`);
    //instance checks
    const hasInstance = await this.instanceRepository.bySN(serial_number);
    if (hasInstance) {
      throw new Error(
        `This ${serial_number} product has already been assigned `,
      );
    }
    const parentInstance = parent_id
      ? await this.instanceRepository.byId(parent_id)
      : null;
    if (parentInstance === undefined) {
      throw new Error(`Parent Instance dont exist.`);
    }
    //products checks
    const hasProduct = await this.productRepository.byId(product_id);
    if (!hasProduct) throw new Error(`This product dont exist.`);
    //employee checks
    const hasEmployee = await this.employeeRepository.byMatricula(matricula);
    if (!hasEmployee) throw new Error(`This Employee dont exist.`);
    const employeeHasProduct = await this.instanceRepository.hasInstance(
      product_id,
      hasEmployee.id,
    );
    if (employeeHasProduct) {
      throw new Error(
        `The enrollment employee: ${matricula} already has an instance of the product.`,
      );
    }
    //stock checks
    const stock = await this.stockRepository.byContractAndProduct(
      contract_id,
      product_id,
    );
    if (!stock) {
      throw new Error(
        `The product has no stock, or the contract has no supply.`,
      );
    }
    if (stock.quantity <= 1) {
      throw new Error(`The stock of this product is less than or equal to 1`);
    }
    //create instance
    const instance = await this.instanceRepository.create(ProductInstance.build(request))
    return right(instance)
  };
}

and with respect to repository calls are small methods using mikro orm:
Here is a repository as an example:

export class ProductInstanceRepository implements IProductInstanceRepository {
  private em: EntityManager;
  constructor(@inject('bootstrap') bootstrap: IBootstrap) {
    this.em = bootstrap.getDatabaseORM().getConnection().em.fork();
  }
  public byArray = async (ids: string[]): Promise<ProductInstance[]> => {
    return await this.em.find(ProductInstance, { serial_number: ids }, [
      'stock',
    ]);
  };
  public create = async (
    instance: ProductInstance,
  ): Promise<ProductInstance> => {
    if (!(instance instanceof ProductInstance))
      throw new Error(`Invalid Data Type`);
    await this.em.persist(instance).flush();
    return instance;
  };
  public update = async (
    serial_number: string,
    data: any,
  ): Promise<ProductInstance> => {
    const instance = await this.em.findOne(ProductInstance, { serial_number });
    if (!instance) throw new Error(`${data.matricula} dont exists`);
    wrap(instance).assign(data);
    await this.em.persist(data).flush();
    return instance;
  };
  public all = async (pagination: Pagination): Promise<ProductInstance[]> => {
    return await this.em.find(ProductInstance, {});
  };
  public byId = async (
    serial_number: string,
  ): Promise<ProductInstance | undefined> => {
    const instance = await this.em.findOne(ProductInstance, { serial_number });
    if (!instance) return;
    return instance;
  };
  public bySN = async (
    serial_number: string,
  ): Promise<ProductInstance | undefined> => {
    const instance = await this.em.findOne(ProductInstance, { serial_number });
    if (!instance) return;
    return instance;
  };
  public hasInstance = async (
    product_id: string,
    employee_id: string,
  ): Promise<boolean> => {
    const parent = await this.em.findOne(ProductInstance, {
      product: { id: product_id },
      employee: { id: employee_id },
    });
    if (!parent) return false;
    return true;
  };
}

But this became a very ugly code, but I’m not getting a solution on how to refactor so much if, because they are essential checks for the logic. I would be very grateful if someone could give me tips on how I can refactor this in a cleaner way.

My logic:

I need to make sure that my type parameter is contained in my enum,

I need to check that there is already an instance of the product in the db,

I need to check if my instance has a parent_id parameter and if that product instance exists, if it is null there is no need for verification,

need to check the existence of the product and stock