✨ Allow setting hex mirrors

Author: fruno-bulax

compiler-cli/src/dependencies.rs

@@ -39,6 +39,7 @@ use crate::{
     build_lock::{BuildLock, Guard},
     cli,
     fs::{self, ProjectIO},
+    get_hex_config,
     http::HttpClient,
     text_layout::space_table,
 };
@@ -66,12 +67,12 @@ pub enum CheckMajorVersions {
 }
 
 pub fn list(paths: &ProjectPaths) -> Result<()> {
-    let (_, manifest) = get_manifest_details(paths)?;
+    let (_, manifest) = get_manifest_details(paths, &get_hex_config()?)?;
     list_manifest_packages(std::io::stdout(), manifest)
 }
 
 pub fn tree(paths: &ProjectPaths, options: TreeOptions) -> Result<()> {
-    let (config, manifest) = get_manifest_details(paths)?;
+    let (config, manifest) = get_manifest_details(paths, &get_hex_config()?)?;
 
     // Initialize the root package since it is not part of the manifest
     let root_package = ManifestPackage {
@@ -92,10 +93,13 @@ pub fn tree(paths: &ProjectPaths, options: TreeOptions) -> Result<()> {
     list_package_and_dependencies_tree(std::io::stdout(), options, packages.clone(), config.name)
 }
 
-fn get_manifest_details(paths: &ProjectPaths) -> Result<(PackageConfig, Manifest)> {
+fn get_manifest_details(
+    paths: &ProjectPaths,
+    hex_config: &hexpm::Config,
+) -> Result<(PackageConfig, Manifest)> {
     let runtime = tokio::runtime::Runtime::new().expect("Unable to start Tokio async runtime");
     let config = crate::config::root_config(paths)?;
-    let package_fetcher = PackageFetcher::new(runtime.handle().clone());
+    let package_fetcher = PackageFetcher::new(runtime.handle().clone(), hex_config.clone());
     let dependency_manager = DependencyManagerConfig {
         use_manifest: UseManifest::Yes,
         check_major_versions: CheckMajorVersions::No,
@@ -105,6 +109,7 @@ fn get_manifest_details(paths: &ProjectPaths) -> Result<(PackageConfig, Manifest
         package_fetcher,
         cli::Reporter::new(),
         Mode::Dev,
+        hex_config.clone(),
     );
     let manifest = dependency_manager
         .resolve_versions(paths, &config, Vec::new())?
@@ -220,10 +225,11 @@ fn list_dependencies_tree(
 }
 
 pub fn outdated(paths: &ProjectPaths) -> Result<()> {
-    let (_, manifest) = get_manifest_details(paths)?;
+    let hex_config = get_hex_config()?;
+    let (_, manifest) = get_manifest_details(paths, &hex_config)?;
 
     let runtime = tokio::runtime::Runtime::new().expect("Unable to start Tokio async runtime");
-    let package_fetcher = PackageFetcher::new(runtime.handle().clone());
+    let package_fetcher = PackageFetcher::new(runtime.handle().clone(), hex_config);
 
     let version_updates = dependency::check_for_version_updates(&manifest, &package_fetcher);
 
@@ -400,13 +406,15 @@ pub fn resolve_and_download<Telem: Telemetry>(
 ) -> Result<Manifest> {
     // Start event loop so we can run async functions to call the Hex API
     let runtime = tokio::runtime::Runtime::new().expect("Unable to start Tokio async runtime");
-    let package_fetcher = PackageFetcher::new(runtime.handle().clone());
+    let hex_config = get_hex_config()?;
+    let package_fetcher = PackageFetcher::new(runtime.handle().clone(), hex_config.clone());
 
     let dependency_manager = config.into_dependency_manager(
         runtime.handle().clone(),
         package_fetcher,
         telemetry,
         Mode::Dev,
+        hex_config,
     );
 
     dependency_manager.resolve_and_download_versions(paths, new_package, packages_to_update)
@@ -443,6 +451,7 @@ async fn add_missing_packages<Telem: Telemetry>(
     local: &LocalPackages,
     project_name: EcoString,
     telemetry: &Telem,
+    hex_config: &hexpm::Config,
 ) -> Result<(), Error> {
     let missing_packages = local.missing_local_packages(manifest, &project_name);
 
@@ -469,7 +478,14 @@ async fn add_missing_packages<Telem: Telemetry>(
     // If we need to download at-least one package
     if missing_hex_packages.peek().is_some() || !missing_git_packages.is_empty() {
         let http = HttpClient::boxed();
-        let downloader = hex::Downloader::new(fs.clone(), fs, http, Untar::boxed(), paths.clone());
+        let downloader = hex::Downloader::new(
+            fs.clone(),
+            fs,
+            http,
+            Untar::boxed(),
+            hex_config.clone(),
+            paths.clone(),
+        );
         let start = Instant::now();
         telemetry.downloading_package("packages");
         downloader
@@ -1089,13 +1105,13 @@ async fn lookup_package(
     name: String,
     version: Version,
     provided: &HashMap<EcoString, ProvidedPackage>,
+    hex_config: &hexpm::Config,
 ) -> Result<ManifestPackage> {
     match provided.get(name.as_str()) {
         Some(provided_package) => Ok(provided_package.to_manifest_package(name.as_str())),
         None => {
-            let config = hexpm::Config::new();
             let release =
-                hex::get_package_release(&name, &version, &config, &HttpClient::new()).await?;
+                hex::get_package_release(&name, &version, hex_config, &HttpClient::new()).await?;
             let build_tools = release
                 .meta
                 .build_tools
@@ -1125,14 +1141,16 @@ struct PackageFetcher {
     runtime_cache: RefCell<HashMap<String, Rc<hexpm::Package>>>,
     runtime: tokio::runtime::Handle,
     http: HttpClient,
+    hex_config: hexpm::Config,
 }
 
 impl PackageFetcher {
-    pub fn new(runtime: tokio::runtime::Handle) -> Self {
+    pub fn new(runtime: tokio::runtime::Handle, hex_config: hexpm::Config) -> Self {
         Self {
             runtime_cache: RefCell::new(HashMap::new()),
             runtime,
             http: HttpClient::new(),
+            hex_config,
         }
     }
 
@@ -1183,8 +1201,7 @@ impl dependency::PackageFetcher for PackageFetcher {
         }
 
         tracing::debug!(package = package, "looking_up_hex_package");
-        let config = hexpm::Config::new();
-        let request = hexpm::repository_v2_get_package_request(package, None, &config);
+        let request = hexpm::repository_v2_get_package_request(package, None, &self.hex_config);
         let response = self
             .runtime
             .block_on(self.http.send(request))

compiler-cli/src/dependencies/dependency_manager.rs

@@ -40,6 +40,7 @@ impl DependencyManagerConfig {
         package_fetcher: P,
         telemetry: Telem,
         mode: Mode,
+        hex_config: hexpm::Config,
     ) -> DependencyManager<Telem, P> {
         DependencyManager {
             runtime,
@@ -49,6 +50,8 @@ impl DependencyManagerConfig {
             mode,
             use_manifest: self.use_manifest,
             check_major_versions: self.check_major_versions,
+
+            hex_config,
         }
     }
 }
@@ -60,6 +63,7 @@ pub struct DependencyManager<Telem, P> {
     use_manifest: UseManifest,
     telemetry: Telem,
     check_major_versions: CheckMajorVersions,
+    hex_config: hexpm::Config,
 }
 
 impl<Telem, P> DependencyManager<Telem, P>
@@ -171,6 +175,7 @@ where
             &local,
             project_name,
             &self.telemetry,
+            &self.hex_config,
         ))?;
 
         if resolved.any_changes() {
@@ -281,11 +286,13 @@ where
         )?;
 
         // Convert the hex packages and local packages into manifest packages
-        let manifest_packages = self.runtime.block_on(future::try_join_all(
-            resolved
-                .into_iter()
-                .map(|(name, version)| lookup_package(name, version, &provided_packages)),
-        ))?;
+        let manifest_packages =
+            self.runtime
+                .block_on(future::try_join_all(resolved.into_iter().map(
+                    |(name, version)| {
+                        lookup_package(name, version, &provided_packages, &self.hex_config)
+                    },
+                )))?;
 
         let manifest = Manifest {
             packages: manifest_packages,

compiler-cli/src/lib.rs

@@ -818,6 +818,36 @@ fn project_paths_at_current_directory_without_toml() -> ProjectPaths {
     ProjectPaths::new(current_dir)
 }
 
+fn get_hex_config() -> Result<hexpm::Config> {
+    let mut config = hexpm::Config::new();
+
+    if let Some(url) = parse_url_from_env_variable("HEXPM_API_URL")? {
+        config.api_base = url;
+    }
+
+    if let Some(url) = parse_url_from_env_variable("HEXPM_REPOSITORY_URL")? {
+        config.repository_base = url;
+    }
+
+    Ok(config)
+}
+
+fn parse_url_from_env_variable(name: &str) -> Result<Option<::http::Uri>> {
+    let Ok(url) = std::env::var(name) else {
+        return Ok(None);
+    };
+    let url = ::http::Uri::from_str(&url)
+        .ok()
+        .filter(|uri| uri.scheme().is_some())
+        .ok_or(Error::InvalidEnvironmentVariable {
+            name: name.into(),
+            value: url,
+            problem: "Expected a valid URL with a scheme.".into(),
+        })?;
+
+    Ok(Some(url))
+}
+
 fn download_dependencies(paths: &ProjectPaths) -> Result<()> {
     _ = dependencies::resolve_and_download(
         paths,

compiler-core/src/error.rs

@@ -337,6 +337,13 @@ file_names.iter().map(|x| x.as_str()).join(", "))]
 
     #[error("Cannot add a package with the same name as a dependency")]
     CannotAddSelfAsDependency { name: EcoString },
+
+    #[error("Invalid environment variable '{name}': {problem}")]
+    InvalidEnvironmentVariable {
+        name: String,
+        value: String,
+        problem: String,
+    },
 }
 
 // A wrapper that ignores the inner value for equality:
@@ -4572,6 +4579,18 @@ add `gleam add {name}` in this project."
                 location: None,
                 hint: None,
             }],
+
+            Error::InvalidEnvironmentVariable { name, value, problem } => vec![Diagnostic {
+                title: "Invalid environment variable".into(),
+                text: wrap_format!(
+                    "You provided the environment variable `{name}` with an invalid value of `{value}`.
+
+{problem}"
+            ),
+                level: Level::Error,
+                location: None,
+                hint: None,
+            }],
         }
     }
 }

compiler-core/src/hex.rs

@@ -165,14 +165,15 @@ impl Downloader {
         fs_writer: Box<dyn FileSystemWriter>,
         http: Box<dyn HttpClient>,
         untar: Box<dyn TarUnpacker>,
+        hex_config: hexpm::Config,
         paths: ProjectPaths,
     ) -> Self {
         Self {
             fs_reader: DebugIgnore(fs_reader),
             fs_writer: DebugIgnore(fs_writer),
             http: DebugIgnore(http),
             untar: DebugIgnore(untar),
-            hex_config: hexpm::Config::new(),
+            hex_config,
             paths,
         }
     }