Delete button in RecyclerView doesn't work properly

Question

So I have a RecyclerView and a corresponding CardView for it (as a single item for list) with some content and delete (remove) button in it.

I want to remove an item from my room db on button click, but the problem is that nothing actually happens.

I've tested with Log.d that clicking on a button is working and I enter the code inside RecyclerView but the main problem is no response from my deleteApod() method at all.

CODE:

ViewModel:

class ApodFavoritesViewModel @Inject constructor(
    private val useCases: ApodUseCases
) : ViewModel() {

    private val _savedApods = MutableStateFlow<List<Apod>?>(null)
    val savedApods get() = _savedApods.asStateFlow()

    init {
        getAll()
    }

    fun getAll() {
        viewModelScope.launch {
            _savedApods.value = useCases.getAllApods()
        }
    }

    fun deleteApod(apod: Apod) {
        viewModelScope.launch {
            useCases.deleteApod(apod)
        }
    }
}

Adapter:

class ApodFavoritesAdapter(
    private var onDelete: (Apod) -> Unit
) : ListAdapter<Apod, ApodFavoritesAdapter.ApodFavoritesViewHolder>(ApodFavoritesDiffCallback) {

    class ApodFavoritesViewHolder(
        val binding: AdapterFavoritesItemBinding,
        private var onDelete: (Apod) -> Unit
    ) : RecyclerView.ViewHolder(binding.root) {

        fun bind(apod: Apod) {
            binding.apply {
                btnRemoveFavorites.setOnClickListener {
                    Log.d("TEST_BUTTON", "Remove")
                    onDelete(apod)
                }
            }
        }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ApodFavoritesViewHolder {
        val layoutInflater = LayoutInflater.from(parent.context)
        return ApodFavoritesViewHolder(
            AdapterFavoritesItemBinding.inflate(layoutInflater, parent, false),
            onDelete
        )
    }

    override fun onBindViewHolder(holder: ApodFavoritesViewHolder, position: Int) {
        val apodItem = getItem(position)
        holder.binding.apply {
            tvFavoritesTitleItem.text = apodItem.title
            tvFavoritesDateItem.text = apodItem.date
            tvFavoritesContentItem.text = apodItem.explanation
            imgFavoritesApodItem.load(apodItem.url)
        }

        holder.bind(apodItem)

    }


    companion object ApodFavoritesDiffCallback : DiffUtil.ItemCallback<Apod>() {
        override fun areItemsTheSame(oldItem: Apod, newItem: Apod): Boolean {
            return oldItem == newItem
        }

        override fun areContentsTheSame(oldItem: Apod, newItem: Apod): Boolean {
            return oldItem.date == newItem.date
        }

    }
}

Fragment:

@AndroidEntryPoint
class ApodFavoritesFragment : Fragment() {

    private var _binding: FragmentApodFavoritesBinding? = null
    private val binding get() = _binding!!

    private val viewModel: ApodFavoritesViewModel by viewModels()

    private lateinit var adapter: ApodFavoritesAdapter

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = FragmentApodFavoritesBinding.inflate(inflater, container, false)

        adapter = ApodFavoritesAdapter(
            onDelete = { apod ->
                viewModel.deleteApod(apod)
            }
        )


        viewLifecycleOwner.lifecycleScope.launchWhenStarted {
            viewModel.savedApods.collectLatest { apods ->
                apods?.let {
                    adapter.submitList(apods)
                }
            }
        }

        binding.rvFavoriteApods.adapter = adapter

        return binding.root
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

Dao:

@Delete
suspend fun deleteApod(apod: ApodEntity)

@Query("SELECT * FROM apod_db")
suspend fun getAll(): List<ApodEntity>

Repo:

override suspend fun deleteApod(apod: ApodEntity) {
    dao.deleteApod(apod)
}

override suspend fun getAll(): List<ApodEntity> {
    return dao.getAll()
}

UseCases:

class DeleteApod(
    val repository: ApodRepository
) {

    suspend operator fun invoke(apod: Apod) {
        repository.deleteApod(apod.toApodEntity())
    }
}

class GetAllApods(
    val repository: ApodRepository
) {

    suspend operator fun invoke(): List<Apod> {
        return repository.getAll().map { it.toApod() }
    }
}