Add --cargo passthrough for cargo-pgrx install/package/run/test #2135

Monorepo/submodule layouts fail because cargo resolves .cargo/config.toml
from the CWD upward, so building from the parent repo picks up the wrong
config and cargo metadata (the first cargo call) dies — e.g. a private
registry declared only in the submodule's config.

Add a repeatable --cargo <FLAG> that is forwarded verbatim to every cargo
invocation cargo-pgrx makes (cargo metadata, cargo rustc, get_version, cargo
test), so global flags like --config/--offline/--locked reach all of them:

cargo pgrx install --cargo=--config=child/.cargo/config.toml

Author: isdaniel

cargo-pgrx/src/cargo.rs

@@ -152,7 +152,7 @@ impl Cargo {
             cmd.arg(features.features.join(" "));
         }
 
-        // And now the miscellaneous build flags!
+        // And now the miscellaneous build flags!, `PGRX_BUILD_FLAGS` stays build-only.
         let flags = env::var("PGRX_BUILD_FLAGS").unwrap_or_default();
         for arg in flags.split_ascii_whitespace() {
             cmd.arg(arg);

cargo-pgrx/src/command/bench.rs

@@ -99,6 +99,7 @@ impl CommandExecute for Bench {
             &self.features,
             self.package.as_deref(),
             self.manifest_path.as_deref(),
+            &[],
         )?;
         let mut resolved_features = self.features.clone();
         let (pg_config, _) = pg_config_and_version(
@@ -117,7 +118,7 @@ impl CommandExecute for Bench {
         }
 
         let postgresql_conf = collect_postgresql_conf_settings(&self.postgresql_conf)?;
-        let extversion = crate::command::install::get_version(&package_manifest_path)?;
+        let extversion = crate::command::install::get_version(&package_manifest_path, &[])?;
         let mut features = resolved_features;
         ensure_feature(&mut features, "pg_bench");
         let profile = CargoProfile::from_flags(
@@ -138,6 +139,7 @@ impl CommandExecute for Bench {
             false,
             self.target.as_deref(),
             &postgresql_conf,
+            &[],
         )?;
 
         if self.resetdb {

cargo-pgrx/src/command/connect.rs

@@ -52,6 +52,7 @@ impl CommandExecute for Connect {
             &Features::default(),
             self.package.as_deref(),
             self.manifest_path.as_deref(),
+            &[],
         )?;
         let (pg_config, _pg_version) = match pg_config_and_version(
             &pgrx,

cargo-pgrx/src/command/get.rs

@@ -34,7 +34,7 @@ impl CommandExecute for Get {
     #[tracing::instrument(level = "error", skip(self))]
     fn execute(self) -> eyre::Result<()> {
         let metadata =
-            crate::metadata::metadata(&Default::default(), self.manifest_path.as_deref())
+            crate::metadata::metadata(&Default::default(), self.manifest_path.as_deref(), &[])
                 .wrap_err("couldn't get cargo metadata")?;
         crate::metadata::validate(self.manifest_path.as_deref(), &metadata)?;
         let package_manifest_path =

cargo-pgrx/src/command/install.rs

@@ -57,6 +57,10 @@ pub(crate) struct Install {
     pub(crate) features: clap_cargo::Features,
     #[clap(long)]
     pub(crate) target: Option<String>,
+    /// Extra flag forwarded verbatim to every `cargo` invocation (repeatable).
+    /// e.g. `--cargo=--config=child/.cargo/config.toml --cargo=--offline`
+    #[clap(long = "cargo", value_name = "FLAG")]
+    pub(crate) cargo: Vec<String>,
     #[clap(from_global, action = ArgAction::Count)]
     pub(crate) verbose: u8,
 }
@@ -72,8 +76,10 @@ impl CommandExecute for Install {
             return sudo_install.execute();
         }
 
-        let metadata = crate::metadata::metadata(&self.features, self.manifest_path.as_deref())
-            .wrap_err("couldn't get cargo metadata")?;
+        let cargo_flags = std::mem::take(&mut self.cargo);
+        let metadata =
+            crate::metadata::metadata(&self.features, self.manifest_path.as_deref(), &cargo_flags)
+                .wrap_err("couldn't get cargo metadata")?;
         crate::metadata::validate(self.manifest_path.as_deref(), &metadata)?;
         let package_manifest_path =
             crate::manifest::manifest_path(&metadata, self.package.as_deref())
@@ -110,6 +116,7 @@ impl CommandExecute for Install {
             None,
             &self.features,
             self.target.as_deref(),
+            &cargo_flags,
         )?;
         Ok(())
     }
@@ -147,6 +154,7 @@ pub(crate) fn install_extension(
     base_directory: Option<PathBuf>,
     features: &clap_cargo::Features,
     target: Option<&str>,
+    cargo_flags: &[String],
 ) -> eyre::Result<Vec<PathBuf>> {
     let mut output_tracking = Vec::new();
 
@@ -158,7 +166,7 @@ pub(crate) fn install_extension(
     let build_manifest_path =
         manifest_path_for_build(user_manifest_path, user_package, package_manifest_path);
     let build_command_output =
-        build_extension(build_manifest_path, user_package, profile, features, target)?;
+        build_extension(build_manifest_path, user_package, profile, features, target, cargo_flags)?;
     let build_command_bytes = build_command_output.stdout;
     let build_command_reader = BufReader::new(build_command_bytes.as_slice());
     let build_command_stream = CargoMessage::parse_stream(build_command_reader);
@@ -192,12 +200,13 @@ pub(crate) fn install_extension(
             true,
             package_manifest_path,
             &mut output_tracking,
+            cargo_flags,
         )?;
     }
 
     {
         let so_name = if versioned_so {
-            let extver = get_version(package_manifest_path)?;
+            let extver = get_version(package_manifest_path, cargo_flags)?;
             // note: versioned so-name format must agree with pgrx-utils
             format!("{extname}-{extver}")
         } else {
@@ -234,6 +243,7 @@ pub(crate) fn install_extension(
             false,
             package_manifest_path,
             &mut output_tracking,
+            cargo_flags,
         )?;
     }
 
@@ -248,6 +258,7 @@ pub(crate) fn install_extension(
         &extdir,
         true,
         &mut output_tracking,
+        cargo_flags,
     )?;
 
     println!("{} installing {}", "    Finished".bold().green(), extname);
@@ -261,6 +272,7 @@ fn copy_file(
     do_filter: bool,
     package_manifest_path: &Path,
     output_tracking: &mut Vec<PathBuf>,
+    cargo_flags: &[String],
 ) -> eyre::Result<()> {
     let Some(dest_dir) = dest.parent() else {
         // what fresh hell could ever cause such an error?
@@ -282,7 +294,7 @@ fn copy_file(
         // we want to filter the contents of the file we're to copy
         let input = fs::read_to_string(src)
             .wrap_err_with(|| format!("failed to read `{}`", src.display()))?;
-        let input = filter_contents(package_manifest_path, input)?;
+        let input = filter_contents(package_manifest_path, input, cargo_flags)?;
 
         fs::write(&dest, input).wrap_err_with(|| {
             format!("failed writing `{}` to `{}`", src.display(), dest.display())
@@ -303,6 +315,7 @@ pub(crate) fn build_extension(
     profile: &CargoProfile,
     features: &clap_cargo::Features,
     target: Option<&str>,
+    cargo_flags: &[String],
 ) -> eyre::Result<std::process::Output> {
     let flags = std::env::var("PGRX_BUILD_FLAGS").unwrap_or_default();
 
@@ -341,6 +354,10 @@ pub(crate) fn build_extension(
         command.arg(arg);
     }
 
+    for arg in cargo_flags {
+        command.arg(arg);
+    }
+
     if let Some(target) = target {
         command.arg("--target");
         command.arg(target);
@@ -388,10 +405,11 @@ fn copy_sql_files(
     extdir: &Path,
     skip_build: bool,
     output_tracking: &mut Vec<PathBuf>,
+    cargo_flags: &[String],
 ) -> eyre::Result<()> {
     let (_, extname) = find_control_file(package_manifest_path)?;
     {
-        let version = get_version(package_manifest_path)?;
+        let version = get_version(package_manifest_path, cargo_flags)?;
         let filename = format!("{extname}--{version}.sql");
         let dest = extdir.join(filename);
 
@@ -432,6 +450,7 @@ fn copy_sql_files(
                     true,
                     package_manifest_path,
                     output_tracking,
+                    cargo_flags,
                 )?;
             }
         }
@@ -482,7 +501,7 @@ pub(crate) fn find_library_file(
 
 static CARGO_VERSION: OnceLock<MemoizeKeyValue> = OnceLock::new();
 
-pub(crate) fn get_version(manifest_path: &Path) -> eyre::Result<String> {
+pub(crate) fn get_version(manifest_path: &Path, cargo_flags: &[String]) -> eyre::Result<String> {
     let path_string = manifest_path.to_owned();
 
     if let Some(version) =
@@ -494,8 +513,9 @@ pub(crate) fn get_version(manifest_path: &Path) -> eyre::Result<String> {
     let version = match get_property(manifest_path, "default_version")? {
         Some(v) => {
             if v == "@CARGO_VERSION@" {
-                let metadata = crate::metadata::metadata(&Default::default(), Some(manifest_path))
-                    .wrap_err("couldn't get cargo metadata")?;
+                let metadata =
+                    crate::metadata::metadata(&Default::default(), Some(manifest_path), cargo_flags)
+                        .wrap_err("couldn't get cargo metadata")?;
                 crate::metadata::validate(Some(manifest_path), &metadata)?;
                 let manifest_path = crate::manifest::manifest_path(&metadata, None)
                     .wrap_err("Couldn't get manifest path")?;
@@ -587,15 +607,19 @@ pub(crate) fn format_display_path(path: &Path) -> eyre::Result<String> {
     Ok(out)
 }
 
-fn filter_contents(manifest_path: &Path, mut input: String) -> eyre::Result<String> {
+fn filter_contents(
+    manifest_path: &Path,
+    mut input: String,
+    cargo_flags: &[String],
+) -> eyre::Result<String> {
     if input.contains("@GIT_HASH@") {
         // avoid doing this if we don't actually have the token
         // the project might not be a git repo so running `git`
         // would fail
         input = input.replace("@GIT_HASH@", &get_git_hash(manifest_path)?);
     }
 
-    input = input.replace("@CARGO_VERSION@", &get_version(manifest_path)?);
+    input = input.replace("@CARGO_VERSION@", &get_version(manifest_path, cargo_flags)?);
 
     Ok(input)
 }

cargo-pgrx/src/command/package.rs

@@ -46,15 +46,21 @@ pub(crate) struct Package {
     pub(crate) features: clap_cargo::Features,
     #[clap(long)]
     pub(crate) target: Option<String>,
+    /// Extra flag forwarded verbatim to every `cargo` invocation (repeatable).
+    /// e.g. `--cargo=--config=child/.cargo/config.toml --cargo=--offline`
+    #[clap(long = "cargo", value_name = "FLAG")]
+    pub(crate) cargo: Vec<String>,
     #[clap(from_global, action = ArgAction::Count)]
     pub(crate) verbose: u8,
 }
 
 impl Package {
     pub(crate) fn perform(mut self) -> eyre::Result<(PathBuf, Vec<PathBuf>)> {
         warn_if_pg_bench_enabled(&self.features, "package");
-        let metadata = crate::metadata::metadata(&self.features, self.manifest_path.as_deref())
-            .wrap_err("couldn't get cargo metadata")?;
+        let cargo_flags = std::mem::take(&mut self.cargo);
+        let metadata =
+            crate::metadata::metadata(&self.features, self.manifest_path.as_deref(), &cargo_flags)
+                .wrap_err("couldn't get cargo metadata")?;
         crate::metadata::validate(self.manifest_path.as_deref(), &metadata)?;
         let package_manifest_path =
             crate::manifest::manifest_path(&metadata, self.package.as_deref())
@@ -96,6 +102,7 @@ impl Package {
             self.test,
             &self.features,
             self.target.as_deref(),
+            &cargo_flags,
         )?;
 
         Ok((out_dir, output_files))
@@ -125,6 +132,7 @@ pub(crate) fn package_extension(
     is_test: bool,
     features: &clap_cargo::Features,
     target: Option<&str>,
+    cargo_flags: &[String],
 ) -> eyre::Result<Vec<PathBuf>> {
     let out_dir_exists = out_dir.try_exists().wrap_err_with(|| {
         format!("failed to access {} while packaging extension", out_dir.display())
@@ -144,6 +152,7 @@ pub(crate) fn package_extension(
         Some(out_dir),
         features,
         target,
+        cargo_flags,
     )
 }
 

cargo-pgrx/src/command/regress.rs

@@ -360,6 +360,7 @@ impl CommandExecute for Regress {
             &self.features,
             self.package.as_deref(),
             self.manifest_path.as_deref(),
+            &[],
         )?;
         let extname = get_property(&manifest_path, "extname")?
             .expect("extension name property `extname` should always be known");

cargo-pgrx/src/command/run.rs

@@ -56,6 +56,10 @@ pub(crate) struct Run {
     install_only: bool,
     #[clap(long)]
     valgrind: bool,
+    /// Extra flag forwarded verbatim to every `cargo` invocation (repeatable).
+    /// e.g. `--cargo=--config=child/.cargo/config.toml --cargo=--offline`
+    #[clap(long = "cargo", value_name = "FLAG")]
+    cargo: Vec<String>,
 }
 
 impl From<&Regress> for Run {
@@ -73,6 +77,7 @@ impl From<&Regress> for Run {
             pgcli: false,
             install_only: false,
             valgrind: regress.valgrind,
+            cargo: Vec::new(),
         }
     }
 }
@@ -98,6 +103,7 @@ impl Run {
             &self.features,
             self.package.as_deref(),
             self.manifest_path.as_deref(),
+            &self.cargo,
         )?;
         let (pg_config, _pg_version) = pg_config_and_version(
             &pgrx,
@@ -130,6 +136,7 @@ impl Run {
             self.valgrind,
             self.target.as_deref(),
             postgresql_conf,
+            &self.cargo,
         )?;
 
         Ok((pg_config, dbname))
@@ -165,6 +172,7 @@ pub(crate) fn run(
     use_valgrind: bool,
     target: Option<&str>,
     postgresql_conf: &HashMap<String, String>,
+    cargo_flags: &[String],
 ) -> eyre::Result<()> {
     // stop postgres
     stop_postgres(pg_config)?;
@@ -180,6 +188,7 @@ pub(crate) fn run(
         None,
         features,
         target,
+        cargo_flags,
     )?;
 
     if install_only {

cargo-pgrx/src/command/schema.rs

@@ -97,6 +97,7 @@ impl CommandExecute for Schema {
             &self.features,
             self.package.as_deref(),
             self.manifest_path.as_deref(),
+            &[],
         )?;
         // This does meaningful mutation, unfortunately
         let (_pg_config, _pg_version) = pg_config_and_version(

cargo-pgrx/src/command/start.rs

@@ -54,6 +54,7 @@ impl CommandExecute for Start {
                 &clap_cargo::Features::default(),
                 me.package.as_deref(),
                 me.manifest_path.as_deref(),
+                &[],
             )?;
 
             let (pg_config, _) =
@@ -65,6 +66,7 @@ impl CommandExecute for Start {
             &clap_cargo::Features::default(),
             self.package.as_deref(),
             self.manifest_path.as_deref(),
+            &[],
         )?;
 
         let postgresql_conf = collect_postgresql_conf_settings(&self.postgresql_conf)?;