feat(components): Rename ValidatedUdfPathAndArgs to ValidatedPathAndArgs (#25680)

GitOrigin-RevId: 0d5153e585d61919531f266bb6931333254cb9bc

Author: Sujay Jayakar

crates/application/src/application_function_runner/mod.rs

@@ -113,7 +113,7 @@ use isolate::{
     ModuleLoader,
     UdfOutcome,
     ValidatedHttpPath,
-    ValidatedUdfPathAndArgs,
+    ValidatedPathAndArgs,
 };
 use keybroker::{
     Identity,
@@ -269,7 +269,7 @@ impl<RT: Runtime> FunctionRouter<RT> {
     pub(crate) async fn execute_query_or_mutation(
         &self,
         tx: Transaction<RT>,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         udf_type: UdfType,
         journal: QueryJournal,
         context: ExecutionContext,
@@ -289,7 +289,7 @@ impl<RT: Runtime> FunctionRouter<RT> {
     pub(crate) async fn execute_action(
         &self,
         tx: Transaction<RT>,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         log_line_sender: mpsc::UnboundedSender<LogLine>,
         context: ExecutionContext,
     ) -> anyhow::Result<ActionOutcome> {
@@ -319,7 +319,7 @@ impl<RT: Runtime> FunctionRouter<RT> {
     async fn function_runner_execute(
         &self,
         mut tx: Transaction<RT>,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         udf_type: UdfType,
         journal: QueryJournal,
         context: ExecutionContext,
@@ -668,7 +668,7 @@ impl<RT: Runtime> ApplicationFunctionRunner<RT> {
 
         let identity = tx.inert_identity();
         let start = self.runtime.monotonic_now();
-        let validate_result = ValidatedUdfPathAndArgs::new(
+        let validate_result = ValidatedPathAndArgs::new(
             caller.allowed_visibility(),
             &mut tx,
             path.clone(),
@@ -982,7 +982,7 @@ impl<RT: Runtime> ApplicationFunctionRunner<RT> {
             anyhow::bail!(unauthorized_error("mutation"));
         }
         let identity = tx.inert_identity();
-        let validate_result = ValidatedUdfPathAndArgs::new(
+        let validate_result = ValidatedPathAndArgs::new(
             allowed_visibility,
             &mut tx,
             path.clone(),
@@ -1147,7 +1147,7 @@ impl<RT: Runtime> ApplicationFunctionRunner<RT> {
             .database
             .begin_with_usage(identity.clone(), usage_tracking)
             .await?;
-        let validate_result = ValidatedUdfPathAndArgs::new(
+        let validate_result = ValidatedPathAndArgs::new(
             caller.allowed_visibility(),
             &mut tx,
             path.clone(),

crates/application/src/cache/mod.rs

@@ -52,7 +52,7 @@ use futures::{
 use isolate::{
     FunctionOutcome,
     UdfOutcome,
-    ValidatedUdfPathAndArgs,
+    ValidatedPathAndArgs,
 };
 use keybroker::Identity;
 use lru::LruCache;
@@ -449,7 +449,7 @@ impl<RT: Runtime> CacheManager<RT> {
                 // checks are transactional with running the query. This is safe because we will
                 // never serve a result based of a stale visibility check since the data read as
                 // part of the visibility check is part of the ReadSet for this query.
-                let validate_result = ValidatedUdfPathAndArgs::new(
+                let validate_result = ValidatedPathAndArgs::new(
                     allowed_visibility,
                     &mut tx,
                     path.clone(),

crates/function_runner/src/lib.rs

@@ -35,7 +35,7 @@ use futures::channel::mpsc;
 use isolate::{
     ActionCallbacks,
     FunctionOutcome,
-    ValidatedUdfPathAndArgs,
+    ValidatedPathAndArgs,
 };
 use keybroker::Identity;
 use model::environment_variables::types::{
@@ -62,7 +62,7 @@ pub mod server;
 pub trait FunctionRunner<RT: Runtime>: Send + Sync + 'static {
     async fn run_function(
         &self,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         udf_type: UdfType,
         identity: Identity,
         ts: RepeatableTimestamp,

crates/function_runner/src/server.rs

@@ -76,7 +76,7 @@ use isolate::{
     ConcurrencyLimiter,
     FunctionOutcome,
     IsolateConfig,
-    ValidatedUdfPathAndArgs,
+    ValidatedPathAndArgs,
 };
 use keybroker::{
     Identity,
@@ -332,7 +332,7 @@ impl<RT: Runtime, S: StorageForInstance<RT>> FunctionRunnerCore<RT, S> {
         action_callbacks: Arc<dyn ActionCallbacks>,
         fetch_client: Arc<dyn FetchClient>,
         log_line_sender: Option<mpsc::UnboundedSender<LogLine>>,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         udf_type: UdfType,
         identity: Identity,
         ts: RepeatableTimestamp,
@@ -504,7 +504,7 @@ impl<RT: Runtime> FunctionRunner<RT> for InProcessFunctionRunner<RT> {
     #[minitrace::trace]
     async fn run_function(
         &self,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         udf_type: UdfType,
         identity: Identity,
         ts: RepeatableTimestamp,

crates/isolate/src/client.rs

@@ -144,7 +144,7 @@ use crate::{
         },
         helpers::validation::{
             ValidatedHttpPath,
-            ValidatedUdfPathAndArgs,
+            ValidatedPathAndArgs,
         },
         schema::SchemaEnvironment,
         udf::DatabaseUdfEnvironment,
@@ -346,7 +346,7 @@ pub trait ActionCallbacks: Send + Sync {
 }
 
 pub struct UdfRequest<RT: Runtime> {
-    pub path_and_args: ValidatedUdfPathAndArgs,
+    pub path_and_args: ValidatedPathAndArgs,
     pub udf_type: UdfType,
     pub identity: InertIdentity,
     pub transaction: Transaction<RT>,
@@ -372,7 +372,7 @@ pub struct ActionRequest<RT: Runtime> {
 #[derive(Clone, PartialEq, Eq)]
 #[cfg_attr(any(test, feature = "testing"), derive(Debug))]
 pub struct ActionRequestParams {
-    pub path_and_args: ValidatedUdfPathAndArgs,
+    pub path_and_args: ValidatedPathAndArgs,
 }
 
 pub struct EnvironmentData<RT: Runtime> {
@@ -654,7 +654,7 @@ impl<RT: Runtime> IsolateClient<RT> {
     pub async fn execute_udf(
         &self,
         udf_type: UdfType,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         transaction: Transaction<RT>,
         journal: QueryJournal,
         context: ExecutionContext,
@@ -755,7 +755,7 @@ impl<RT: Runtime> IsolateClient<RT> {
     #[minitrace::trace]
     pub async fn execute_action(
         &self,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         transaction: Transaction<RT>,
         action_callbacks: Arc<dyn ActionCallbacks>,
         fetch_client: Arc<dyn FetchClient>,

crates/isolate/src/environment/action/outcome.rs

@@ -31,7 +31,7 @@ use crate::{
         SyscallTrace,
     },
     http_action::HttpActionRequestHead,
-    ValidatedUdfPathAndArgs,
+    ValidatedPathAndArgs,
 };
 
 #[derive(Debug, Clone)]
@@ -77,7 +77,7 @@ impl ActionOutcome {
             result,
             syscall_trace,
         }: ActionOutcomeProto,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         identity: InertIdentity,
     ) -> anyhow::Result<Self> {
         let result = result.ok_or_else(|| anyhow::anyhow!("Missing result"))?;
@@ -217,7 +217,7 @@ mod tests {
     use super::{
         ActionOutcome,
         ActionOutcomeProto,
-        ValidatedUdfPathAndArgs,
+        ValidatedPathAndArgs,
     };
 
     proptest! {
@@ -232,7 +232,7 @@ mod tests {
             let arguments = udf_outcome.arguments.clone();
             let version = udf_outcome.udf_server_version.clone();
             let identity = udf_outcome_clone.identity.clone();
-            let path_and_args = ValidatedUdfPathAndArgs::new_for_tests(
+            let path_and_args = ValidatedPathAndArgs::new_for_tests(
                 udf_path,
                 arguments,
                 version

crates/isolate/src/environment/helpers/outcome.rs

@@ -12,7 +12,7 @@ use crate::{
         },
         udf::outcome::UdfOutcome,
     },
-    ValidatedUdfPathAndArgs,
+    ValidatedPathAndArgs,
 };
 
 /// A `UdfOutcome` represents a successful execution of a developer's function
@@ -31,7 +31,7 @@ pub enum FunctionOutcome {
 impl FunctionOutcome {
     pub fn from_proto(
         FunctionOutcomeProto { outcome }: FunctionOutcomeProto,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         identity: InertIdentity,
     ) -> anyhow::Result<Self> {
         let outcome = outcome.ok_or_else(|| anyhow::anyhow!("Missing outcome"))?;

crates/isolate/src/environment/helpers/validation.rs

@@ -175,28 +175,28 @@ async fn udf_version<RT: Runtime>(
 /// - Checking the args size.
 /// - Checking that the args pass validation.
 ///
-/// This should only be constructed via `ValidatedUdfPath::new` to use the type
-/// system to enforce that validation is never skipped.
+/// This should only be constructed via `ValidatedPathAndArgs::new` to use the
+/// type system to enforce that validation is never skipped.
 #[derive(Clone, Eq, PartialEq)]
 #[cfg_attr(any(test, feature = "testing"), derive(Debug))]
-pub struct ValidatedUdfPathAndArgs {
+pub struct ValidatedPathAndArgs {
     path: CanonicalizedComponentFunctionPath,
     args: ConvexArray,
     // Not set for system modules.
     npm_version: Option<Version>,
 }
 
 #[cfg(any(test, feature = "testing"))]
-impl Arbitrary for ValidatedUdfPathAndArgs {
+impl Arbitrary for ValidatedPathAndArgs {
     type Parameters = ();
 
-    type Strategy = impl Strategy<Value = ValidatedUdfPathAndArgs>;
+    type Strategy = impl Strategy<Value = ValidatedPathAndArgs>;
 
     fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
         use proptest::prelude::*;
 
         any::<(CanonicalizedComponentFunctionPath, ConvexArray)>().prop_map(|(path, args)| {
-            ValidatedUdfPathAndArgs {
+            ValidatedPathAndArgs {
                 path,
                 args,
                 npm_version: None,
@@ -205,9 +205,9 @@ impl Arbitrary for ValidatedUdfPathAndArgs {
     }
 }
 
-impl ValidatedUdfPathAndArgs {
+impl ValidatedPathAndArgs {
     /// Check if the function being called matches the allowed visibility and
-    /// return a ValidatedUdfPath or an appropriate JsError.
+    /// return a ValidatedPathAndARgs or an appropriate JsError.
     ///
     /// We want to use the same error message for "this function exists, but
     /// with the wrong visibility" and "this function does not exist" so we
@@ -218,7 +218,7 @@ impl ValidatedUdfPathAndArgs {
         path: CanonicalizedComponentFunctionPath,
         args: ConvexArray,
         expected_udf_type: UdfType,
-    ) -> anyhow::Result<Result<ValidatedUdfPathAndArgs, JsError>> {
+    ) -> anyhow::Result<Result<ValidatedPathAndArgs, JsError>> {
         if path.udf_path.is_system() {
             anyhow::ensure!(
                 path.component.is_root(),
@@ -228,7 +228,7 @@ impl ValidatedUdfPathAndArgs {
             // We don't analyze system modules, so we don't validate anything
             // except the identity for them.
             let result = if tx.identity().is_admin() || tx.identity().is_system() {
-                Ok(ValidatedUdfPathAndArgs {
+                Ok(ValidatedPathAndArgs {
                     path,
                     args,
                     npm_version: None,
@@ -321,7 +321,7 @@ impl ValidatedUdfPathAndArgs {
             ))));
         }
 
-        Ok(Ok(ValidatedUdfPathAndArgs {
+        Ok(Ok(ValidatedPathAndArgs {
             path,
             args,
             npm_version: Some(udf_version),
@@ -386,15 +386,15 @@ impl ValidatedUdfPathAndArgs {
     }
 }
 
-impl TryFrom<ValidatedUdfPathAndArgs> for pb::common::PathAndArgs {
+impl TryFrom<ValidatedPathAndArgs> for pb::common::PathAndArgs {
     type Error = anyhow::Error;
 
     fn try_from(
-        ValidatedUdfPathAndArgs {
+        ValidatedPathAndArgs {
             path,
             args,
             npm_version,
-        }: ValidatedUdfPathAndArgs,
+        }: ValidatedPathAndArgs,
     ) -> anyhow::Result<Self> {
         let args_json = JsonValue::from(args);
         let args = serde_json::to_vec(&args_json)?;
@@ -476,16 +476,16 @@ mod test {
 
     use proptest::prelude::*;
 
-    use crate::ValidatedUdfPathAndArgs;
+    use crate::ValidatedPathAndArgs;
     proptest! {
         #![proptest_config(
             ProptestConfig { failure_persistence: None, ..ProptestConfig::default() }
         )]
 
         #[test]
-        fn test_udf_path_proto_roundtrip(v in any::<ValidatedUdfPathAndArgs>()) {
+        fn test_udf_path_proto_roundtrip(v in any::<ValidatedPathAndArgs>()) {
             let proto = pb::common::PathAndArgs::try_from(v.clone()).unwrap();
-            let v2 = ValidatedUdfPathAndArgs::from_proto(proto).unwrap();
+            let v2 = ValidatedPathAndArgs::from_proto(proto).unwrap();
             assert_eq!(v, v2);
         }
     }

crates/isolate/src/environment/udf/outcome.rs

@@ -38,7 +38,7 @@ use crate::{
         JsonPackedValue,
         SyscallTrace,
     },
-    ValidatedUdfPathAndArgs,
+    ValidatedPathAndArgs,
 };
 
 #[derive(Debug, Clone)]
@@ -207,7 +207,7 @@ impl UdfOutcome {
             result,
             syscall_trace,
         }: UdfOutcomeProto,
-        path_and_args: ValidatedUdfPathAndArgs,
+        path_and_args: ValidatedPathAndArgs,
         identity: InertIdentity,
     ) -> anyhow::Result<Self> {
         let rng_seed = rng_seed.ok_or_else(|| anyhow::anyhow!("Missing rng_seed"))?;
@@ -257,7 +257,7 @@ mod tests {
     use super::{
         UdfOutcome,
         UdfOutcomeProto,
-        ValidatedUdfPathAndArgs,
+        ValidatedPathAndArgs,
     };
 
     proptest! {
@@ -272,7 +272,7 @@ mod tests {
             let arguments = udf_outcome.arguments.clone();
             let version = udf_outcome.udf_server_version.clone();
             let identity = udf_outcome_clone.identity.clone();
-            let path_and_args = ValidatedUdfPathAndArgs::new_for_tests(
+            let path_and_args = ValidatedPathAndArgs::new_for_tests(
                 udf_path,
                 arguments,
                 version