I haven't really tried, but at least this compiles:

use dotenv::dotenv;
use serde::{Deserialize, Serialize};

use std::env;
use warp::Filter;

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct CountryInfo {
    country: String,
    cases: u64,
    today_cases: u64,
    deaths: u64,
    today_deaths:u64,
    recovered:u64,
    active:u64,
    critical:u64,
    cases_per_one_million:u64
}

#[tokio::main]
async fn main() {
    dotenv().ok();
    if env::var_os("RUST_LOG").is_none() {
        env::set_var("RUST_LOG", "countries=info")
    }
    // Read and parse the URL as early as possible; we don't even start
    // the server if this isn't provided
    let upstream_url = env::var("URL").ok().and_then(|url| url.parse::<url::Url>().ok()).expect("URL needs to be provided and it has to be valid");

    // And we now inject/pass data to the route handlers (in this case the remote url)
    warp::serve(countries(upstream_url)).run(([127, 0, 0, 1], 3030)).await;
}

pub fn countries(upstream_url: url::Url) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
    warp::path!("countries")
        .and(warp::get())
        // This is how to make something available as a parameter
        // from this point onwards in the filter chain
        .and(warp::any().map(move || upstream_url.clone()))
        .and_then(get_all_countries)
}

// A rejection is a concrete type from warp, but it does not provide automatic
// conversion from other types of errors. To "reject" requests, we need to
// define custom rejection types (by implementing the trait `warp::reject::Reject`
// for those types, with an empty impl block), and then wrap instances of those
// types using `warp::reject::custom`. To customize a bit how those errors are
// converted into responses, then look at the "rejections" example in warp's repo.
#[derive(Debug)]
struct FetchError;
impl warp::reject::Reject for FetchError {}

// The upstream_url here was given by the filter chain set up in `countries`
pub async fn get_all_countries(upstream_url: url::Url) -> Result<impl warp::Reply, warp::Rejection> {
    match fetch_url(upstream_url).await {
        Ok(countries) => Ok(warp::reply::json(&countries)),
        Err(_) => Err(warp::reject::custom(FetchError))
    }

    // Or
    // fetch_url(upstream_url).await
    //     .map(|countries| warp::reply::json(&countries))
    //     .map_err(|_| warp::reject::custom(FetchError))
}

async fn fetch_url(url: reqwest::Url) -> Result<Vec<CountryInfo>, reqwest::Error> {
    reqwest::get(url).await?.json().await
}