Resolution refactor

packages/builder/src/client_config_builder.rs

@@ -3,7 +3,7 @@ use std::{collections::HashMap, sync::{Arc}};
 use polywrap_core::{
     client::{ClientConfig, UriRedirect},
     env::{Env,Envs},
-    resolvers::{uri_resolver_like::UriResolverLike}, 
+    resolution::uri_resolver::UriResolver, 
     uri::Uri, wrapper::Wrapper, package::WrapPackage
 };
 
@@ -298,7 +298,7 @@ impl ClientBuilder for BuilderConfig {
         self
     }
 
-    fn add_resolver(&mut self, resolver: UriResolverLike) -> &mut Self {
+    fn add_resolver(&mut self, resolver: Arc<dyn UriResolver>) -> &mut Self {
         match self.resolvers.as_mut() {
             Some(resolvers) => {
                 resolvers.push(resolver);
@@ -311,7 +311,7 @@ impl ClientBuilder for BuilderConfig {
         self
     }
 
-    fn add_resolvers(&mut self, resolvers: Vec<UriResolverLike>) -> &mut Self {
+    fn add_resolvers(&mut self, resolvers: Vec<Arc<dyn UriResolver>>) -> &mut Self {
         for resolver in resolvers.into_iter() {
             self.add_resolver(resolver);
         }

packages/builder/src/helpers.rs

@@ -2,14 +2,14 @@ use std::sync::Arc;
 
 use polywrap_core::{
     client::ClientConfig,
-    resolvers::{
-        recursive_resolver::RecursiveResolver,
-        static_resolver::{StaticResolver, StaticResolverLike},
+    resolution::{
         uri_resolver::UriResolver,
-        uri_resolver_like::UriResolverLike,
     },
 };
-use polywrap_resolvers::extendable_uri_resolver::ExtendableUriResolver;
+use polywrap_resolvers::{
+    extendable_uri_resolver::ExtendableUriResolver, 
+    static_resolver::{StaticResolverLike, StaticResolver}, recursive_resolver::RecursiveResolver, resolver_vec
+};
 use serde_json::Value;
 
 use crate::types::BuilderConfig;
@@ -47,17 +47,13 @@ pub fn build_resolver(builder: BuilderConfig) -> ClientConfig {
             static_resolvers.push(StaticResolverLike::Redirect(r));
         }
     }
-    let static_resolver = StaticResolver::from(static_resolvers);
-    let extendable_resolver = ExtendableUriResolver::new(None);
-
-    let resolvers = vec![
-        UriResolverLike::Resolver(Arc::new(static_resolver)),
-        UriResolverLike::Resolver(Arc::new(extendable_resolver)),
-    ];
 
     ClientConfig {
         envs: builder.envs.clone(),
         interfaces: builder.interfaces.clone(),
-        resolver: Arc::new(RecursiveResolver::from(resolvers)) as Arc<dyn UriResolver>,
+        resolver: Arc::new(RecursiveResolver::from(resolver_vec![
+            StaticResolver::from(static_resolvers),
+            ExtendableUriResolver::new(None),
+        ])),
     }
 }

packages/builder/src/types.rs

@@ -3,9 +3,8 @@ use std::sync::{Arc};
 use polywrap_core::{
     interface_implementation::InterfaceImplementations,
     env::{Envs,Env}, 
-    resolvers::{uri_resolver_like::UriResolverLike},
     uri::Uri, 
-    client::{UriRedirect, ClientConfig}, package::WrapPackage, wrapper::Wrapper
+    client::{UriRedirect, ClientConfig}, package::WrapPackage, wrapper::Wrapper, resolution::uri_resolver::UriResolver
 };
 
 #[derive(Clone)]
@@ -15,7 +14,7 @@ pub struct BuilderConfig {
     pub wrappers: Option<Vec<(Uri, Arc<dyn Wrapper>)>>,
     pub packages: Option<Vec<(Uri, Arc<dyn WrapPackage>)>>,
     pub redirects: Option<Vec<UriRedirect>>,
-    pub resolvers: Option<Vec<UriResolverLike>>,
+    pub resolvers: Option<Vec<Arc<dyn UriResolver>>>,
 }
 
 pub trait ClientBuilder {
@@ -48,8 +47,8 @@ pub trait ClientBuilder {
     fn add_redirect(&mut self, from: Uri, to: Uri) -> &mut Self;
     fn add_redirects(&mut self, redirects: Vec<UriRedirect>) -> &mut Self;
     fn remove_redirect(&mut self, from: &Uri) -> &mut Self;
-    fn add_resolver(&mut self, resolver: UriResolverLike) -> &mut Self;
-    fn add_resolvers(&mut self, resolver: Vec<UriResolverLike>) -> &mut Self;
+    fn add_resolver(&mut self, resolver: Arc<dyn UriResolver>) -> &mut Self;
+    fn add_resolvers(&mut self, resolver: Vec<Arc<dyn UriResolver>>) -> &mut Self;
 }
 
 pub trait ClientConfigHandler {

packages/builder/tests/test_builder.rs

@@ -1,6 +1,6 @@
 #![feature(closure_lifetime_binder)]
 #![feature(trait_upcasting)]
-use std::{collections::HashMap};
+use std::collections::HashMap;
 
 use polywrap_client_builder::types::{BuilderConfig, ClientBuilder};
 use polywrap_core::{
@@ -241,4 +241,4 @@ fn test_wrappers() {
     let mock_wrapper_as_any = &*(mock_wrapper) as &dyn std::any::Any;
     let expected_wrapper = mock_wrapper_as_any.downcast_ref::<MockWrapper>().unwrap();
     assert_eq!(received_wrapper.name, expected_wrapper.name);
-}
+}

packages/client/src/client.rs

@@ -6,13 +6,13 @@ use polywrap_core::{
     error::Error,
     interface_implementation::InterfaceImplementations,
     invoker::Invoker,
-    resolvers::uri_resolution_context::UriResolutionContext,
-    resolvers::{
+    resolution::uri_resolution_context::UriResolutionContext,
+    resolution::{
         uri_resolution_context::{UriPackageOrWrapper, UriResolutionStep},
-        uri_resolver::{UriResolver, UriResolverHandler}, helpers::get_env_from_resolution_path,
+        uri_resolver::UriResolver, helpers::get_env_from_resolution_path,
     },
     uri::Uri,
-    wrapper::Wrapper, wrap_loader::WrapLoader, wrap_invoker::WrapInvoker,
+    wrapper::Wrapper, wrap_loader::WrapLoader, wrap_invoker::WrapInvoker, uri_resolver_handler::UriResolverHandler,
 };
 use polywrap_msgpack::decode;
 use serde::de::DeserializeOwned;
@@ -138,7 +138,7 @@ impl Invoker for PolywrapClient {
     }
 
     fn get_implementations(&self, uri: &Uri) -> Result<Vec<Uri>, Error> {
-        polywrap_core::resolvers::helpers::get_implementations(uri, self.get_interfaces(), self)
+        polywrap_core::resolution::helpers::get_implementations(uri, self.get_interfaces(), self)
     }
 
     fn get_interfaces(&self) -> Option<InterfaceImplementations> {
@@ -264,12 +264,12 @@ mod client_tests {
         client::ClientConfig,
         error::Error,
         invoker::Invoker,
-        resolvers::{
+        resolution::{
             uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-            uri_resolver::{UriResolver, UriResolverHandler},
+            uri_resolver::UriResolver,
         },
         uri::Uri,
-        wrapper::{GetFileOptions, Wrapper}, wrap_loader::WrapLoader,
+        wrapper::{GetFileOptions, Wrapper}, wrap_loader::WrapLoader, uri_resolver_handler::UriResolverHandler,
     };
     use std::sync::Arc;
 

packages/client/src/subinvoker.rs

@@ -1,7 +1,7 @@
 use std::sync::{Mutex, Arc};
 
 use polywrap_core::{
-    resolvers::uri_resolution_context::UriResolutionContext, 
+    resolution::uri_resolution_context::UriResolutionContext, 
     invoker::Invoker, env::Env, error::Error, uri::Uri, interface_implementation::InterfaceImplementations
 };
 

packages/client/tests/test_env_with_invoke.rs

@@ -4,12 +4,13 @@ use polywrap_client::msgpack::msgpack;
 
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::recursive_resolver::RecursiveResolver;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
-use polywrap_core::resolvers::uri_resolution_context::UriPackageOrWrapper;
-use polywrap_core::resolvers::uri_resolver_like::UriResolverLike;
+use polywrap_core::resolution::uri_resolution_context::UriPackageOrWrapper;
+use polywrap_core::resolution::uri_resolver::UriResolver;
 use polywrap_resolvers::base_resolver::BaseResolver;
+use polywrap_resolvers::recursive_resolver::RecursiveResolver;
+use polywrap_resolvers::resolver_vec;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -278,14 +279,13 @@ fn env_can_be_registered_for_any_uri_in_resolution_path() {
             let file_reader = SimpleFileReader::new();
             let fs_resolver = FilesystemResolver::new(Arc::new(file_reader));
 
-            // Use the RecursiveResolver because it tracks resolution path (unlike BaseResolver)
-            let base_resolver = RecursiveResolver::from(vec![
-                UriResolverLike::Resolver(Arc::new(StaticResolver::new(resolvers))),
-                UriResolverLike::Resolver(Arc::new(fs_resolver)),
-            ]);
             let config = ClientConfig {
                 envs: Some(envs),
-                resolver: Arc::new(base_resolver),
+                // Use the RecursiveResolver because it tracks resolution path (unlike BaseResolver)
+                resolver: Arc::new(RecursiveResolver::from(resolver_vec![
+                    StaticResolver::new(resolvers),
+                    fs_resolver,
+                ])),
                 interfaces: None,
             };
 
@@ -322,14 +322,13 @@ fn env_can_be_registered_for_any_uri_in_resolution_path() {
             let file_reader = SimpleFileReader::new();
             let fs_resolver = FilesystemResolver::new(Arc::new(file_reader));
 
-            // Use the RecursiveResolver because it tracks resolution path (unlike BaseResolver)
-            let base_resolver = RecursiveResolver::from(vec![
-                UriResolverLike::Resolver(Arc::new(StaticResolver::new(resolvers))),
-                UriResolverLike::Resolver(Arc::new(fs_resolver)),
-            ]);
             let config = ClientConfig {
                 envs: Some(envs),
-                resolver: Arc::new(base_resolver),
+                // Use the RecursiveResolver because it tracks resolution path (unlike BaseResolver)
+                resolver: Arc::new(RecursiveResolver::from(resolver_vec![
+                    StaticResolver::new(resolvers),
+                    fs_resolver,
+                ])),
                 interfaces: None,
             };
 

packages/client/tests/test_env_with_subinvoke.rs

@@ -4,10 +4,10 @@ use polywrap_client::msgpack::msgpack;
 
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
-use polywrap_core::resolvers::uri_resolution_context::UriPackageOrWrapper;
+use polywrap_core::resolution::uri_resolution_context::UriPackageOrWrapper;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;

packages/client/tests/test_interface_implementation.rs

@@ -4,9 +4,9 @@ use polywrap_client::msgpack::msgpack;
 
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use serde::Deserialize;
 use std::collections::HashMap;

packages/client/tests/test_map_type.rs

@@ -7,9 +7,9 @@ use polywrap_client::core::uri::Uri;
 use polywrap_client::plugin::Map;
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use serde::{Deserialize, Serialize};
 

packages/client/tests/test_plugin_invocation.rs

@@ -1,8 +1,9 @@
 
 use JSON::{json, from_value, Value};
 use polywrap_client::client::PolywrapClient;
-use polywrap_core::{invoker::{Invoker}, env::Env, resolvers::static_resolver::{StaticResolverLike, StaticResolver}, package::WrapPackage, uri::Uri, client::ClientConfig};
+use polywrap_core::{invoker::{Invoker}, env::Env, package::WrapPackage, uri::Uri, client::ClientConfig};
 use polywrap_msgpack::msgpack;
+use polywrap_resolvers::static_resolver::{StaticResolver, StaticResolverLike};
 use wrap_manifest_schemas::versions::{WrapManifest, WrapManifestAbi};
 use std::{sync::Arc, collections::HashMap};
 use serde_json as JSON;

packages/client/tests/test_uri_resolvers.rs

@@ -6,19 +6,15 @@ use std::sync::Arc;
 use polywrap_client::client::PolywrapClient;
 use polywrap_client::resolvers::uri_resolver_wrapper::UriResolverWrapper;
 
-use polywrap_client::core::{
-    resolvers::{
-        uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext},
-    },
-    uri::Uri,
-};
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
 use polywrap_core::interface_implementation::InterfaceImplementations;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
-use polywrap_core::resolvers::uri_resolver::UriResolver;
+use polywrap_core::resolution::uri_resolution_context::{UriResolutionContext, UriPackageOrWrapper};
+use polywrap_core::resolution::uri_resolver::UriResolver;
+use polywrap_core::uri::Uri;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 use polywrap_wasm::wasm_wrapper::WasmWrapper;
 

packages/client/tests/tests_subinvoke.rs

@@ -5,11 +5,11 @@ use polywrap_client::client::PolywrapClient;
 use polywrap_client::core::uri::Uri;
 use polywrap_core::client::ClientConfig;
 use polywrap_core::file_reader::SimpleFileReader;
-use polywrap_core::resolvers::static_resolver::StaticResolver;
-use polywrap_core::resolvers::uri_resolution_context::UriPackageOrWrapper;
+use polywrap_core::resolution::uri_resolution_context::UriPackageOrWrapper;
 use polywrap_msgpack::msgpack;
 use polywrap_resolvers::base_resolver::BaseResolver;
 use polywrap_resolvers::simple_file_resolver::FilesystemResolver;
+use polywrap_resolvers::static_resolver::StaticResolver;
 use polywrap_tests_utils::helpers::get_tests_path;
 
 #[test]

packages/core/src/client.rs

@@ -2,9 +2,10 @@ use std::sync::Arc;
 
 use crate::uri::Uri;
 use crate::interface_implementation::InterfaceImplementations;
-use crate::resolvers::uri_resolver::{UriResolverHandler, UriResolver};
+use crate::resolution::uri_resolver::UriResolver;
 use crate::env::Envs;
 use crate::invoker::Invoker;
+use crate::uri_resolver_handler::UriResolverHandler;
 use crate::wrap_invoker::WrapInvoker;
 use crate::wrap_loader::WrapLoader;
 

packages/core/src/invoker.rs

@@ -1,5 +1,5 @@
 use crate::{
-    error::Error, uri::Uri, resolvers::uri_resolution_context::UriResolutionContext, env::Env, 
+    error::Error, uri::Uri, resolution::uri_resolution_context::UriResolutionContext, env::Env, 
     interface_implementation::InterfaceImplementations,
 };
 pub trait Invoker: Send + Sync {

packages/core/src/lib.rs

@@ -10,4 +10,5 @@ pub mod package;
 pub mod file_reader;
 pub mod env;
 pub mod interface_implementation;
-pub mod resolvers;
+pub mod uri_resolver_handler;
+pub mod resolution;

packages/core/src/resolution/mod.rs

@@ -0,0 +1,4 @@
+pub mod uri_resolver;
+pub mod uri_resolution_context;
+pub mod helpers;
+pub mod get_uri_resolution_path;

packages/core/src/resolvers/uri_resolution_context.rs → packages/core/src/resolution/uri_resolution_context.rs

@@ -1,7 +1,7 @@
 use crate::{package::WrapPackage, wrapper::Wrapper, error::Error};
 use std::{collections::HashMap, sync::Arc, vec};
 
-use crate::{uri::Uri};
+use crate::uri::Uri;
 
 #[derive(Clone)]
 pub enum UriPackageOrWrapper {

packages/core/src/resolution/uri_resolver.rs

@@ -0,0 +1,16 @@
+use std::fmt::Debug;
+use std::sync::Arc;
+
+use crate::error::Error;
+use crate::invoker::Invoker;
+use crate::uri::Uri;
+use super::uri_resolution_context::{UriPackageOrWrapper, UriResolutionContext};
+
+pub trait UriResolver: Send + Sync + Debug {
+    fn try_resolve_uri(
+        &self,
+        uri: &Uri,
+        client: Arc<dyn Invoker>,
+        resolution_context: &mut UriResolutionContext,
+    ) -> Result<UriPackageOrWrapper, Error>;
+}