fix(cli): validate transform VRL and conditions with --no-environment

vector validate --no-environment now compiles VRL programs (remap) and
conditions (filter) to catch expression errors without requiring environment
access. Previously these errors were only caught when running without the flag.

TransformConfig::validate now accepts a TransformContext instead of a bare
schema::Definition, so transforms can access enrichment_tables, metrics_storage,
and the merged schema definition for type-aware VRL compilation.

Environment-dependent transforms (aws_ec2_metadata) use the default no-op
validate impl and are unaffected.

Closes: #15037

Author: pront

changelog.d/15037_validate_no_environment_vrl.fix.md

@@ -0,0 +1,3 @@
+Fixed `vector validate --no-environment` so it reports VRL and condition compilation errors for transforms without requiring full environment-dependent component initialization.
+
+authors: pront

src/conditions/mod.rs

@@ -210,6 +210,14 @@ impl AnyCondition {
             AnyCondition::Map(m) => m.build(enrichment_tables, metrics_storage),
         }
     }
+
+    pub fn validate(
+        &self,
+        enrichment_tables: &vector_lib::enrichment::TableRegistry,
+        metrics_storage: &MetricsStorage,
+    ) -> crate::Result<()> {
+        self.build(enrichment_tables, metrics_storage).map(|_| ())
+    }
 }
 
 impl From<ConditionConfig> for AnyCondition {

src/config/transform.rs

@@ -162,6 +162,7 @@ pub struct TransformContext {
     /// (e.g. `aws_ec2_metadata`, `throttle`) clone this and pass it to [`crate::cpu_time::spawn_timed`] so
     /// their CPU is attributed to the component alongside the main transform task.
     pub cpu_ns: Option<Counter>,
+
 }
 
 impl Default for TransformContext {
@@ -250,7 +251,7 @@ pub trait TransformConfig: DynClone + NamedComponent + core::fmt::Debug + Send +
     ///
     /// If validation does not succeed, an error variant containing a list of all validation errors
     /// is returned.
-    fn validate(&self, _merged_definition: &schema::Definition) -> Result<(), Vec<String>> {
+    fn validate(&self, _context: &TransformContext) -> Result<(), Vec<String>> {
         Ok(())
     }
 

src/config/validation.rs

@@ -9,7 +9,7 @@ use super::{
     ComponentKey, Config, OutputId, Resource, builder::ConfigBuilder,
     transform::get_transform_output_ids,
 };
-use crate::config::schema;
+use crate::config::TransformContext;
 
 /// Minimum value (exclusive) for EWMA alpha options.
 /// The alpha value must be strictly greater than this value.
@@ -234,10 +234,7 @@ pub fn check_outputs(config: &ConfigBuilder) -> Result<(), Vec<String>> {
     }
 
     for (key, transform) in config.transforms.iter() {
-        // use the most general definition possible, since the real value isn't known yet.
-        let definition = schema::Definition::any();
-
-        if let Err(errs) = transform.inner.validate(&definition) {
+        if let Err(errs) = transform.inner.validate(&TransformContext::default()) {
             errors.extend(errs.into_iter().map(|msg| format!("Transform {key} {msg}")));
         }
 

src/transforms/exclusive_route/config.rs

@@ -101,7 +101,7 @@ impl TransformConfig for ExclusiveRouteConfig {
         Input::all()
     }
 
-    fn validate(&self, _: &schema::Definition) -> Result<(), Vec<String>> {
+    fn validate(&self, _: &TransformContext) -> Result<(), Vec<String>> {
         let mut errors = Vec::new();
 
         let mut counts = std::collections::HashMap::new();

src/transforms/filter.rs

@@ -50,6 +50,12 @@ impl TransformConfig for FilterConfig {
         )?)))
     }
 
+    fn validate(&self, context: &TransformContext) -> Result<(), Vec<String>> {
+        self.condition
+            .validate(&context.enrichment_tables, &context.metrics_storage)
+            .map_err(|e| vec![e.to_string()])
+    }
+
     fn input(&self) -> Input {
         Input::all()
     }

src/transforms/remap.rs

@@ -277,6 +277,16 @@ impl TransformConfig for RemapConfig {
         Ok(transform)
     }
 
+    fn validate(&self, context: &TransformContext) -> std::result::Result<(), Vec<String>> {
+        self.compile_vrl_program(
+            context.enrichment_tables.clone(),
+            context.metrics_storage.clone(),
+            context.merged_schema_definition.clone(),
+        )
+        .map(|_| ())
+        .map_err(|e| vec![e.to_string()])
+    }
+
     fn input(&self) -> Input {
         Input::all()
     }

src/transforms/route.rs

@@ -131,7 +131,7 @@ impl TransformConfig for RouteConfig {
         Input::all()
     }
 
-    fn validate(&self, _: &schema::Definition) -> Result<(), Vec<String>> {
+    fn validate(&self, _: &TransformContext) -> Result<(), Vec<String>> {
         if self.route.contains_key(UNMATCHED_ROUTE) {
             Err(vec![format!(
                 "cannot have a named output with reserved name: `{UNMATCHED_ROUTE}`"

src/transforms/sample/config.rs

@@ -222,7 +222,7 @@ impl TransformConfig for SampleConfig {
         Input::new(DataType::Log | DataType::Trace)
     }
 
-    fn validate(&self, _: &schema::Definition) -> Result<(), Vec<String>> {
+    fn validate(&self, _: &TransformContext) -> Result<(), Vec<String>> {
         self.sample_rate()
             .map(|_| ())
             .map_err(|e| vec![e.to_string()])
@@ -317,7 +317,7 @@ mod tests {
             exclude: None,
         };
 
-        assert!(config.validate(&crate::schema::Definition::any()).is_ok());
+        assert!(config.validate(&crate::config::TransformContext::default()).is_ok());
     }
 
     #[test]

src/validate.rs

@@ -1,13 +1,15 @@
 #![allow(missing_docs)]
 
-use std::{fmt, fs::remove_dir_all, path::PathBuf};
+use std::{collections::HashMap, fmt, fs::remove_dir_all, path::PathBuf};
 
 use clap::Parser;
 use colored::*;
 use exitcode::ExitCode;
+use vector_vrl_metrics::MetricsStorage;
 
 use crate::{
-    config::{self, Config, ConfigDiff, loading::ConfigBuilderLoader},
+    config::{self, Config, ConfigDiff, TransformContext, loading::ConfigBuilderLoader},
+    schema::Definition,
     topology::{
         self,
         builder::{TopologyPieces, TopologyPiecesBuilder},
@@ -117,13 +119,13 @@ pub async fn validate(opts: &Opts, color: bool) -> ExitCode {
         None => return exitcode::CONFIG,
     };
 
-    if !opts.no_environment {
-        if let Some(tmp_directory) = create_tmp_directory(&mut config, &mut fmt) {
-            validated &= validate_environment(opts, &config, &mut fmt).await;
-            remove_tmp_directory(tmp_directory);
-        } else {
-            validated = false;
-        }
+    if opts.no_environment {
+        validated &= validate_transforms_no_environment(&config, &mut fmt).await;
+    } else if let Some(tmp_directory) = create_tmp_directory(&mut config, &mut fmt) {
+        validated &= validate_environment(opts, &config, &mut fmt).await;
+        remove_tmp_directory(tmp_directory);
+    } else {
+        validated = false;
     }
 
     if validated {
@@ -180,6 +182,54 @@ pub fn validate_config(opts: &Opts, fmt: &mut Formatter) -> Option<Config> {
     Some(config)
 }
 
+async fn validate_transforms_no_environment(config: &Config, fmt: &mut Formatter) -> bool {
+    let enrichment_tables = vector_lib::enrichment::TableRegistry::default();
+    let metrics_storage = MetricsStorage::default();
+    let mut definition_cache = HashMap::new();
+    let mut errors = Vec::new();
+
+    for (key, transform) in config.transforms() {
+        let input_definitions = topology::schema::input_definitions(
+            &transform.inputs,
+            config,
+            enrichment_tables.clone(),
+            &mut definition_cache,
+        )
+        .unwrap_or_default();
+
+        let merged_schema_definition = input_definitions
+            .iter()
+            .map(|(_, definition)| definition.clone())
+            .reduce(Definition::merge)
+            .unwrap_or_else(Definition::any);
+
+        let context = TransformContext {
+            key: Some(key.clone()),
+            globals: config.global.clone(),
+            enrichment_tables: enrichment_tables.clone(),
+            metrics_storage: metrics_storage.clone(),
+            merged_schema_definition,
+            schema: config.schema,
+            ..Default::default()
+        };
+
+        if let Err(errs) = transform.inner.validate(&context) {
+            for err in errs {
+                errors.push(format!("Transform \"{key}\": {err}"));
+            }
+        }
+    }
+
+    if errors.is_empty() {
+        fmt.success("Transform configuration");
+        true
+    } else {
+        fmt.title("Transform errors");
+        fmt.sub_error(errors);
+        false
+    }
+}
+
 async fn validate_environment(opts: &Opts, config: &Config, fmt: &mut Formatter) -> bool {
     let diff = ConfigDiff::initial(config);