You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opendal.apache.org by xu...@apache.org on 2025/12/04 09:27:44 UTC

(opendal) branch main updated: refactor: Reuse from_uri logic inside via iter (#6862)

This is an automated email from the ASF dual-hosted git repository.

xuanwo pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/opendal.git


The following commit(s) were added to refs/heads/main by this push:
     new efe627ad4 refactor: Reuse from_uri logic inside via iter (#6862)
efe627ad4 is described below

commit efe627ad41783fb0a23a8d3346a6db4a369c79f0
Author: Xuanwo <gi...@xuanwo.io>
AuthorDate: Thu Dec 4 17:27:38 2025 +0800

    refactor: Reuse from_uri logic inside via iter (#6862)
    
    * refactor: Reuse from_uri logic inside via iter
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
    
    * Fix tests
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
    
    * Fix build
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
    
    * Fix tests
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
    
    ---------
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
---
 core/core/src/services/alluxio/config.rs     |  10 +-
 core/core/src/services/azdls/config.rs       |   9 +-
 core/core/src/services/azfile/config.rs      |   9 +-
 core/core/src/services/dbfs/config.rs        |  10 +-
 core/core/src/services/ftp/config.rs         |  15 +--
 core/core/src/services/hdfs/config.rs        |  18 +--
 core/core/src/services/hdfs_native/config.rs |  18 +--
 core/core/src/services/http/config.rs        |  24 ++--
 core/core/src/services/huggingface/config.rs |  96 ++++++++--------
 core/core/src/services/ipfs/config.rs        |  18 +--
 core/core/src/services/ipmfs/config.rs       |  10 +-
 core/core/src/services/koofr/config.rs       |   9 +-
 core/core/src/services/lakefs/config.rs      |   9 +-
 core/core/src/services/memcached/config.rs   |  10 +-
 core/core/src/services/pcloud/config.rs      |  17 ++-
 core/core/src/services/seafile/config.rs     |  56 ++++------
 core/core/src/services/sftp/config.rs        |  10 +-
 core/core/src/services/webdav/config.rs      |  10 +-
 core/core/src/services/webhdfs/config.rs     |  18 +--
 core/core/src/types/operator/builder.rs      | 158 +++------------------------
 core/core/src/types/operator/registry.rs     | 116 ++++++++++++++++++--
 core/core/src/types/operator/uri.rs          |  29 ++++-
 22 files changed, 319 insertions(+), 360 deletions(-)

diff --git a/core/core/src/services/alluxio/config.rs b/core/core/src/services/alluxio/config.rs
index f513ac70e..70512d74b 100644
--- a/core/core/src/services/alluxio/config.rs
+++ b/core/core/src/services/alluxio/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::ALLUXIO_SCHEME;
 use super::backend::AlluxioBuilder;
 
 /// Config for alluxio services support.
@@ -53,13 +52,10 @@ impl crate::Configurator for AlluxioConfig {
     type Builder = AlluxioBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", ALLUXIO_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("http://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("http://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
diff --git a/core/core/src/services/azdls/config.rs b/core/core/src/services/azdls/config.rs
index c4e5a7643..b4db8c059 100644
--- a/core/core/src/services/azdls/config.rs
+++ b/core/core/src/services/azdls/config.rs
@@ -74,13 +74,10 @@ impl crate::Configurator for AzdlsConfig {
     type Builder = AzdlsBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", AZDLS_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("https://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("https://{authority}"));
+        }
 
         if let Some(host) = uri.name() {
             if let Some(account) = host.split('.').next() {
diff --git a/core/core/src/services/azfile/config.rs b/core/core/src/services/azfile/config.rs
index ed7bd1ef7..e6624c717 100644
--- a/core/core/src/services/azfile/config.rs
+++ b/core/core/src/services/azfile/config.rs
@@ -54,13 +54,10 @@ impl crate::Configurator for AzfileConfig {
     type Builder = AzfileBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", AZFILE_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("https://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("https://{authority}"));
+        }
 
         if let Some(host) = uri.name() {
             if let Some(account) = host.split('.').next() {
diff --git a/core/core/src/services/dbfs/config.rs b/core/core/src/services/dbfs/config.rs
index c027899eb..236282524 100644
--- a/core/core/src/services/dbfs/config.rs
+++ b/core/core/src/services/dbfs/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::DBFS_SCHEME;
 use super::backend::DbfsBuilder;
 
 /// [Dbfs](https://docs.databricks.com/api/azure/workspace/dbfs)'s REST API support.
@@ -47,13 +46,10 @@ impl crate::Configurator for DbfsConfig {
     type Builder = DbfsBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", DBFS_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("https://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("https://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
diff --git a/core/core/src/services/ftp/config.rs b/core/core/src/services/ftp/config.rs
index 40ad9ed60..f8624cba7 100644
--- a/core/core/src/services/ftp/config.rs
+++ b/core/core/src/services/ftp/config.rs
@@ -51,16 +51,13 @@ impl crate::Configurator for FtpConfig {
     type Builder = FtpBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", FTP_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert(
-            "endpoint".to_string(),
-            format!("{FTP_SCHEME}://{authority}"),
-        );
+        if let Some(authority) = uri.authority() {
+            map.insert(
+                "endpoint".to_string(),
+                format!("{FTP_SCHEME}://{authority}"),
+            );
+        }
 
         if let Some(root) = uri.root() {
             map.insert("root".to_string(), root.to_string());
diff --git a/core/core/src/services/hdfs/config.rs b/core/core/src/services/hdfs/config.rs
index ca5b184dd..ddfcc1c95 100644
--- a/core/core/src/services/hdfs/config.rs
+++ b/core/core/src/services/hdfs/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::HDFS_SCHEME;
 use super::backend::HdfsBuilder;
 
 /// [Hadoop Distributed File System (HDFS™)](https://hadoop.apache.org/) support.
@@ -64,13 +63,10 @@ impl crate::Configurator for HdfsConfig {
     type Builder = HdfsBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", HDFS_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("name_node".to_string(), format!("hdfs://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("name_node".to_string(), format!("hdfs://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
@@ -104,4 +100,12 @@ mod tests {
         assert_eq!(cfg.name_node.as_deref(), Some("hdfs://cluster.local:8020"));
         assert_eq!(cfg.root.as_deref(), Some("user/data"));
     }
+
+    #[test]
+    fn from_uri_allows_missing_authority() {
+        let uri = OperatorUri::new("hdfs", Vec::<(String, String)>::new()).unwrap();
+
+        let cfg = HdfsConfig::from_uri(&uri).unwrap();
+        assert!(cfg.name_node.is_none());
+    }
 }
diff --git a/core/core/src/services/hdfs_native/config.rs b/core/core/src/services/hdfs_native/config.rs
index f846ade15..eeb14e177 100644
--- a/core/core/src/services/hdfs_native/config.rs
+++ b/core/core/src/services/hdfs_native/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::HDFS_NATIVE_SCHEME;
 use super::backend::HdfsNativeBuilder;
 
 /// Config for HdfsNative services support.
@@ -50,13 +49,10 @@ impl crate::Configurator for HdfsNativeConfig {
     type Builder = HdfsNativeBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", HDFS_NATIVE_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("name_node".to_string(), format!("hdfs://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("name_node".to_string(), format!("hdfs://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
@@ -90,4 +86,12 @@ mod tests {
         assert_eq!(cfg.name_node.as_deref(), Some("hdfs://namenode:9000"));
         assert_eq!(cfg.root.as_deref(), Some("user/project"));
     }
+
+    #[test]
+    fn from_uri_allows_missing_authority() {
+        let uri = OperatorUri::new("hdfs-native", Vec::<(String, String)>::new()).unwrap();
+
+        let cfg = HdfsNativeConfig::from_uri(&uri).unwrap();
+        assert!(cfg.name_node.is_none());
+    }
 }
diff --git a/core/core/src/services/http/config.rs b/core/core/src/services/http/config.rs
index 196bc8e75..9bf9fb785 100644
--- a/core/core/src/services/http/config.rs
+++ b/core/core/src/services/http/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::HTTP_SCHEME;
 use super::backend::HttpBuilder;
 
 /// Config for Http service support.
@@ -53,16 +52,13 @@ impl crate::Configurator for HttpConfig {
     type Builder = HttpBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", HTTP_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert(
-            "endpoint".to_string(),
-            format!("{}://{}", uri.scheme(), authority),
-        );
+        if let Some(authority) = uri.authority() {
+            map.insert(
+                "endpoint".to_string(),
+                format!("{}://{}", uri.scheme(), authority),
+            );
+        }
 
         if let Some(root) = uri.root() {
             map.insert("root".to_string(), root.to_string());
@@ -99,6 +95,14 @@ mod tests {
         assert_eq!(cfg.root.as_deref(), Some("static/assets"));
     }
 
+    #[test]
+    fn from_uri_allows_missing_authority() {
+        let uri = OperatorUri::new("http", Vec::<(String, String)>::new()).unwrap();
+
+        let cfg = HttpConfig::from_uri(&uri).unwrap();
+        assert!(cfg.endpoint.is_none());
+    }
+
     #[test]
     fn from_uri_preserves_query_options() {
         let uri = OperatorUri::new(
diff --git a/core/core/src/services/huggingface/config.rs b/core/core/src/services/huggingface/config.rs
index 508eb289f..7ac04a668 100644
--- a/core/core/src/services/huggingface/config.rs
+++ b/core/core/src/services/huggingface/config.rs
@@ -73,6 +73,7 @@ impl crate::Configurator for HuggingfaceConfig {
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
         let mut map = uri.options().clone();
+        map.retain(|_, v| !v.is_empty());
 
         if let Some(repo_type) = uri.name() {
             if !repo_type.is_empty() {
@@ -80,60 +81,47 @@ impl crate::Configurator for HuggingfaceConfig {
             }
         }
 
-        let raw_path = uri.root().ok_or_else(|| {
-            crate::Error::new(
-                crate::ErrorKind::ConfigInvalid,
-                "uri path must include owner and repo",
-            )
-            .with_context("service", HUGGINGFACE_SCHEME)
-        })?;
-
-        let mut segments = raw_path.splitn(4, '/');
-        let owner = segments.next().filter(|s| !s.is_empty()).ok_or_else(|| {
-            crate::Error::new(
-                crate::ErrorKind::ConfigInvalid,
-                "repository owner is required in uri path",
-            )
-            .with_context("service", HUGGINGFACE_SCHEME)
-        })?;
-        let repo = segments.next().filter(|s| !s.is_empty()).ok_or_else(|| {
-            crate::Error::new(
-                crate::ErrorKind::ConfigInvalid,
-                "repository name is required in uri path",
-            )
-            .with_context("service", HUGGINGFACE_SCHEME)
-        })?;
+        if let Some(raw_path) = uri.root() {
+            let parts: Vec<_> = raw_path.split('/').filter(|s| !s.is_empty()).collect();
 
-        map.insert("repo_id".to_string(), format!("{owner}/{repo}"));
+            if parts.len() >= 2 {
+                map.insert("repo_id".to_string(), format!("{}/{}", parts[0], parts[1]));
 
-        if let Some(segment) = segments.next() {
-            if map.contains_key("revision") {
-                let mut root_value = segment.to_string();
-                if let Some(rest) = segments.next() {
-                    if !rest.is_empty() {
+                if parts.len() >= 3 {
+                    if map.contains_key("revision") {
+                        let root_value = parts[2..].join("/");
                         if !root_value.is_empty() {
-                            root_value.push('/');
-                            root_value.push_str(rest);
-                        } else {
-                            root_value = rest.to_string();
+                            map.insert("root".to_string(), root_value);
+                        }
+                    } else {
+                        map.insert("revision".to_string(), parts[2].to_string());
+                        if parts.len() > 3 {
+                            let root_value = parts[3..].join("/");
+                            if !root_value.is_empty() {
+                                map.insert("root".to_string(), root_value);
+                            }
                         }
                     }
                 }
-                if !root_value.is_empty() {
-                    map.insert("root".to_string(), root_value);
-                }
+            } else if parts.is_empty() {
+                // no owner/repo provided, fall back to options-only
             } else {
-                if !segment.is_empty() {
-                    map.insert("revision".to_string(), segment.to_string());
-                }
-                if let Some(rest) = segments.next() {
-                    if !rest.is_empty() {
-                        map.insert("root".to_string(), rest.to_string());
-                    }
-                }
+                return Err(crate::Error::new(
+                    crate::ErrorKind::ConfigInvalid,
+                    "repository owner and name are required in uri path",
+                )
+                .with_context("service", HUGGINGFACE_SCHEME));
             }
         }
 
+        if !map.contains_key("repo_id") {
+            return Err(crate::Error::new(
+                crate::ErrorKind::ConfigInvalid,
+                "repo_id is required via uri path or option",
+            )
+            .with_context("service", HUGGINGFACE_SCHEME));
+        }
+
         Self::from_iter(map)
     }
 
@@ -178,6 +166,26 @@ mod tests {
         assert_eq!(cfg.root.as_deref(), Some("data/train"));
     }
 
+    #[test]
+    fn from_uri_allows_options_only() {
+        let uri = OperatorUri::new(
+            "huggingface",
+            vec![
+                ("repo_type".to_string(), "model".to_string()),
+                ("repo_id".to_string(), "opendal/sample".to_string()),
+                ("revision".to_string(), "main".to_string()),
+                ("root".to_string(), "".to_string()),
+            ],
+        )
+        .unwrap();
+
+        let cfg = HuggingfaceConfig::from_uri(&uri).unwrap();
+        assert_eq!(cfg.repo_type.as_deref(), Some("model"));
+        assert_eq!(cfg.repo_id.as_deref(), Some("opendal/sample"));
+        assert_eq!(cfg.revision.as_deref(), Some("main"));
+        assert!(cfg.root.is_none());
+    }
+
     #[test]
     fn from_uri_requires_owner_and_repo() {
         let uri = OperatorUri::new(
diff --git a/core/core/src/services/ipfs/config.rs b/core/core/src/services/ipfs/config.rs
index 04c613910..c06e8621b 100644
--- a/core/core/src/services/ipfs/config.rs
+++ b/core/core/src/services/ipfs/config.rs
@@ -18,7 +18,6 @@
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::IPFS_SCHEME;
 use super::backend::IpfsBuilder;
 
 /// Config for IPFS file system support.
@@ -36,13 +35,10 @@ impl crate::Configurator for IpfsConfig {
     type Builder = IpfsBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", IPFS_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("http://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("http://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
@@ -80,4 +76,12 @@ mod tests {
         assert_eq!(cfg.endpoint.as_deref(), Some("http://ipfs.io"));
         assert_eq!(cfg.root.as_deref(), Some("ipfs/QmHash/path"));
     }
+
+    #[test]
+    fn from_uri_allows_missing_authority() {
+        let uri = OperatorUri::new("ipfs", Vec::<(String, String)>::new()).unwrap();
+
+        let cfg = IpfsConfig::from_uri(&uri).unwrap();
+        assert!(cfg.endpoint.is_none());
+    }
 }
diff --git a/core/core/src/services/ipmfs/config.rs b/core/core/src/services/ipmfs/config.rs
index 8187aea6e..3e2c21de4 100644
--- a/core/core/src/services/ipmfs/config.rs
+++ b/core/core/src/services/ipmfs/config.rs
@@ -18,7 +18,6 @@
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::IPMFS_SCHEME;
 use super::builder::IpmfsBuilder;
 
 /// Config for IPFS MFS support.
@@ -36,13 +35,10 @@ impl crate::Configurator for IpmfsConfig {
     type Builder = IpmfsBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", IPMFS_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("http://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("http://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
diff --git a/core/core/src/services/koofr/config.rs b/core/core/src/services/koofr/config.rs
index de623fab2..b23be5fe3 100644
--- a/core/core/src/services/koofr/config.rs
+++ b/core/core/src/services/koofr/config.rs
@@ -53,11 +53,6 @@ impl crate::Configurator for KoofrConfig {
     type Builder = KoofrBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", KOOFR_SCHEME)
-        })?;
-
         let raw_path = uri.root().ok_or_else(|| {
             crate::Error::new(
                 crate::ErrorKind::ConfigInvalid,
@@ -76,7 +71,9 @@ impl crate::Configurator for KoofrConfig {
         })?;
 
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("https://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("https://{authority}"));
+        }
         map.insert("email".to_string(), email.to_string());
 
         if let Some(rest) = segments.next() {
diff --git a/core/core/src/services/lakefs/config.rs b/core/core/src/services/lakefs/config.rs
index d6c374e3d..dff70ec74 100644
--- a/core/core/src/services/lakefs/config.rs
+++ b/core/core/src/services/lakefs/config.rs
@@ -70,11 +70,6 @@ impl crate::Configurator for LakefsConfig {
     type Builder = LakefsBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", LAKEFS_SCHEME)
-        })?;
-
         let raw_path = uri.root().ok_or_else(|| {
             crate::Error::new(
                 crate::ErrorKind::ConfigInvalid,
@@ -102,7 +97,9 @@ impl crate::Configurator for LakefsConfig {
         })?;
 
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("https://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("https://{authority}"));
+        }
         map.insert("repository".to_string(), repository.to_string());
 
         if let Some(rest) = remainder {
diff --git a/core/core/src/services/memcached/config.rs b/core/core/src/services/memcached/config.rs
index 943f38ce8..0ace5014d 100644
--- a/core/core/src/services/memcached/config.rs
+++ b/core/core/src/services/memcached/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::MEMCACHED_SCHEME;
 use super::backend::MemcachedBuilder;
 use crate::raw::*;
 
@@ -64,13 +63,10 @@ impl crate::Configurator for MemcachedConfig {
     type Builder = MemcachedBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", MEMCACHED_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("tcp://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("tcp://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
diff --git a/core/core/src/services/pcloud/config.rs b/core/core/src/services/pcloud/config.rs
index d8a05c24a..08423136d 100644
--- a/core/core/src/services/pcloud/config.rs
+++ b/core/core/src/services/pcloud/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::PCLOUD_SCHEME;
 use super::backend::PcloudBuilder;
 
 /// Config for Pcloud services support.
@@ -54,13 +53,10 @@ impl crate::Configurator for PcloudConfig {
     type Builder = PcloudBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", PCLOUD_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("https://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("https://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
@@ -101,9 +97,10 @@ mod tests {
     }
 
     #[test]
-    fn from_uri_requires_authority() {
-        let uri = OperatorUri::new("pcloud:///drive", Vec::<(String, String)>::new()).unwrap();
+    fn from_uri_allows_missing_authority() {
+        let uri = OperatorUri::new("pcloud", Vec::<(String, String)>::new()).unwrap();
 
-        assert!(PcloudConfig::from_uri(&uri).is_err());
+        let cfg = PcloudConfig::from_uri(&uri).unwrap();
+        assert!(cfg.endpoint.is_empty());
     }
 }
diff --git a/core/core/src/services/seafile/config.rs b/core/core/src/services/seafile/config.rs
index 5e79bbb49..fd855e6a6 100644
--- a/core/core/src/services/seafile/config.rs
+++ b/core/core/src/services/seafile/config.rs
@@ -59,36 +59,29 @@ impl crate::Configurator for SeafileConfig {
     type Builder = SeafileBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", SEAFILE_SCHEME)
-        })?;
+        let mut map = uri.options().clone();
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("https://{authority}"));
+        }
+        if let Some(raw_path) = uri.root() {
+            let mut segments = raw_path.splitn(2, '/');
+            if let Some(repo_name) = segments.next().filter(|s| !s.is_empty()) {
+                map.insert("repo_name".to_string(), repo_name.to_string());
+            }
 
-        let raw_path = uri.root().ok_or_else(|| {
-            crate::Error::new(
-                crate::ErrorKind::ConfigInvalid,
-                "uri path must start with repo name",
-            )
-            .with_context("service", SEAFILE_SCHEME)
-        })?;
+            if let Some(rest) = segments.next() {
+                if !rest.is_empty() {
+                    map.insert("root".to_string(), rest.to_string());
+                }
+            }
+        }
 
-        let mut segments = raw_path.splitn(2, '/');
-        let repo_name = segments.next().filter(|s| !s.is_empty()).ok_or_else(|| {
-            crate::Error::new(
+        if !map.contains_key("repo_name") {
+            return Err(crate::Error::new(
                 crate::ErrorKind::ConfigInvalid,
-                "repo name is required in uri path",
+                "repo_name is required via uri path or option",
             )
-            .with_context("service", SEAFILE_SCHEME)
-        })?;
-
-        let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("https://{authority}"));
-        map.insert("repo_name".to_string(), repo_name.to_string());
-
-        if let Some(rest) = segments.next() {
-            if !rest.is_empty() {
-                map.insert("root".to_string(), rest.to_string());
-            }
+            .with_context("service", SEAFILE_SCHEME));
         }
 
         Self::from_iter(map)
@@ -122,15 +115,4 @@ mod tests {
         assert_eq!(cfg.repo_name, "myrepo".to_string());
         assert_eq!(cfg.root.as_deref(), Some("projects/app"));
     }
-
-    #[test]
-    fn from_uri_requires_repo_name() {
-        let uri = OperatorUri::new(
-            "seafile://files.example.com",
-            Vec::<(String, String)>::new(),
-        )
-        .unwrap();
-
-        assert!(SeafileConfig::from_uri(&uri).is_err());
-    }
 }
diff --git a/core/core/src/services/sftp/config.rs b/core/core/src/services/sftp/config.rs
index 999da4378..033268e7d 100644
--- a/core/core/src/services/sftp/config.rs
+++ b/core/core/src/services/sftp/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::SFTP_SCHEME;
 use super::backend::SftpBuilder;
 
 /// Config for Sftp Service support.
@@ -55,13 +54,10 @@ impl crate::Configurator for SftpConfig {
     type Builder = SftpBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", SFTP_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), authority.to_string());
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), authority.to_string());
+        }
 
         if let Some(root) = uri.root() {
             map.insert("root".to_string(), root.to_string());
diff --git a/core/core/src/services/webdav/config.rs b/core/core/src/services/webdav/config.rs
index de1c9c76a..e9be3fbd3 100644
--- a/core/core/src/services/webdav/config.rs
+++ b/core/core/src/services/webdav/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::WEBDAV_SCHEME;
 use super::backend::WebdavBuilder;
 
 /// Config for [WebDAV](https://datatracker.ietf.org/doc/html/rfc4918) backend support.
@@ -57,13 +56,10 @@ impl crate::Configurator for WebdavConfig {
     type Builder = WebdavBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", WEBDAV_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("https://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("https://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             map.insert("root".to_string(), root.to_string());
diff --git a/core/core/src/services/webhdfs/config.rs b/core/core/src/services/webhdfs/config.rs
index 110862f56..76761c25c 100644
--- a/core/core/src/services/webhdfs/config.rs
+++ b/core/core/src/services/webhdfs/config.rs
@@ -20,7 +20,6 @@ use std::fmt::Debug;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::WEBHDFS_SCHEME;
 use super::backend::WebhdfsBuilder;
 
 /// Config for WebHDFS support.
@@ -58,13 +57,10 @@ impl crate::Configurator for WebhdfsConfig {
     type Builder = WebhdfsBuilder;
 
     fn from_uri(uri: &crate::types::OperatorUri) -> crate::Result<Self> {
-        let authority = uri.authority().ok_or_else(|| {
-            crate::Error::new(crate::ErrorKind::ConfigInvalid, "uri authority is required")
-                .with_context("service", WEBHDFS_SCHEME)
-        })?;
-
         let mut map = uri.options().clone();
-        map.insert("endpoint".to_string(), format!("http://{authority}"));
+        if let Some(authority) = uri.authority() {
+            map.insert("endpoint".to_string(), format!("http://{authority}"));
+        }
 
         if let Some(root) = uri.root() {
             if !root.is_empty() {
@@ -102,4 +98,12 @@ mod tests {
         assert_eq!(cfg.root.as_deref(), Some("user/hadoop/data"));
         assert_eq!(cfg.user_name.as_deref(), Some("hadoop"));
     }
+
+    #[test]
+    fn from_uri_allows_missing_authority() {
+        let uri = OperatorUri::new("webhdfs", Vec::<(String, String)>::new()).unwrap();
+
+        let cfg = WebhdfsConfig::from_uri(&uri).unwrap();
+        assert!(cfg.endpoint.is_none());
+    }
 }
diff --git a/core/core/src/types/operator/builder.rs b/core/core/src/types/operator/builder.rs
index 76055ac52..305429650 100644
--- a/core/core/src/types/operator/builder.rs
+++ b/core/core/src/types/operator/builder.rs
@@ -179,154 +179,11 @@ impl Operator {
     ///     Ok(())
     /// }
     /// ```
-    #[allow(unused_variables, unreachable_code)]
     pub fn via_iter(
         scheme: impl AsRef<str>,
         iter: impl IntoIterator<Item = (String, String)>,
     ) -> Result<Operator> {
-        let op = match scheme.as_ref() {
-            #[cfg(feature = "services-aliyun-drive")]
-            services::ALIYUN_DRIVE_SCHEME => {
-                Self::from_iter::<services::AliyunDrive>(iter)?.finish()
-            }
-            #[cfg(feature = "services-alluxio")]
-            services::ALLUXIO_SCHEME => Self::from_iter::<services::Alluxio>(iter)?.finish(),
-            #[cfg(feature = "services-azblob")]
-            services::AZBLOB_SCHEME => Self::from_iter::<services::Azblob>(iter)?.finish(),
-            #[cfg(feature = "services-azdls")]
-            services::AZDLS_SCHEME => Self::from_iter::<services::Azdls>(iter)?.finish(),
-            #[cfg(feature = "services-azfile")]
-            services::AZFILE_SCHEME => Self::from_iter::<services::Azfile>(iter)?.finish(),
-            #[cfg(feature = "services-b2")]
-            services::B2_SCHEME => Self::from_iter::<services::B2>(iter)?.finish(),
-            #[cfg(feature = "services-cacache")]
-            services::CACACHE_SCHEME => Self::from_iter::<services::Cacache>(iter)?.finish(),
-            #[cfg(feature = "services-cloudflare-kv")]
-            services::CLOUDFLARE_KV_SCHEME => {
-                Self::from_iter::<services::CloudflareKv>(iter)?.finish()
-            }
-            #[cfg(feature = "services-compfs")]
-            services::COMPFS_SCHEME => Self::from_iter::<services::Compfs>(iter)?.finish(),
-            #[cfg(feature = "services-cos")]
-            services::COS_SCHEME => Self::from_iter::<services::Cos>(iter)?.finish(),
-            #[cfg(feature = "services-d1")]
-            services::D1_SCHEME => Self::from_iter::<services::D1>(iter)?.finish(),
-            #[cfg(feature = "services-dashmap")]
-            services::DASHMAP_SCHEME => Self::from_iter::<services::Dashmap>(iter)?.finish(),
-            #[cfg(feature = "services-dbfs")]
-            services::DBFS_SCHEME => Self::from_iter::<services::Dbfs>(iter)?.finish(),
-            #[cfg(feature = "services-dropbox")]
-            services::DROPBOX_SCHEME => Self::from_iter::<services::Dropbox>(iter)?.finish(),
-            #[cfg(feature = "services-etcd")]
-            services::ETCD_SCHEME => Self::from_iter::<services::Etcd>(iter)?.finish(),
-            #[cfg(feature = "services-foundationdb")]
-            services::FOUNDATIONDB_SCHEME => {
-                Self::from_iter::<services::Foundationdb>(iter)?.finish()
-            }
-            #[cfg(feature = "services-fs")]
-            services::FS_SCHEME => Self::from_iter::<services::Fs>(iter)?.finish(),
-            #[cfg(feature = "services-ftp")]
-            services::FTP_SCHEME => Self::from_iter::<services::Ftp>(iter)?.finish(),
-            #[cfg(feature = "services-gcs")]
-            services::GCS_SCHEME => Self::from_iter::<services::Gcs>(iter)?.finish(),
-            #[cfg(feature = "services-gdrive")]
-            services::GDRIVE_SCHEME => Self::from_iter::<services::Gdrive>(iter)?.finish(),
-            #[cfg(feature = "services-ghac")]
-            services::GHAC_SCHEME => Self::from_iter::<services::Ghac>(iter)?.finish(),
-            #[cfg(feature = "services-github")]
-            services::GITHUB_SCHEME => Self::from_iter::<services::Github>(iter)?.finish(),
-            #[cfg(feature = "services-gridfs")]
-            services::GRIDFS_SCHEME => Self::from_iter::<services::Gridfs>(iter)?.finish(),
-            #[cfg(feature = "services-hdfs")]
-            services::HDFS_SCHEME => Self::from_iter::<services::Hdfs>(iter)?.finish(),
-            #[cfg(feature = "services-hdfs-native")]
-            services::HDFS_NATIVE_SCHEME => Self::from_iter::<services::HdfsNative>(iter)?.finish(),
-            #[cfg(feature = "services-http")]
-            services::HTTP_SCHEME => Self::from_iter::<services::Http>(iter)?.finish(),
-            #[cfg(feature = "services-huggingface")]
-            services::HUGGINGFACE_SCHEME => {
-                Self::from_iter::<services::Huggingface>(iter)?.finish()
-            }
-            #[cfg(feature = "services-ipfs")]
-            services::IPFS_SCHEME => Self::from_iter::<services::Ipfs>(iter)?.finish(),
-            #[cfg(feature = "services-ipmfs")]
-            services::IPMFS_SCHEME => Self::from_iter::<services::Ipmfs>(iter)?.finish(),
-            #[cfg(feature = "services-koofr")]
-            services::KOOFR_SCHEME => Self::from_iter::<services::Koofr>(iter)?.finish(),
-            #[cfg(feature = "services-lakefs")]
-            services::LAKEFS_SCHEME => Self::from_iter::<services::Lakefs>(iter)?.finish(),
-            #[cfg(feature = "services-memcached")]
-            services::MEMCACHED_SCHEME => Self::from_iter::<services::Memcached>(iter)?.finish(),
-            #[cfg(feature = "services-memory")]
-            services::MEMORY_SCHEME => Self::from_iter::<services::Memory>(iter)?.finish(),
-            #[cfg(feature = "services-mini-moka")]
-            services::MINI_MOKA_SCHEME => Self::from_iter::<services::MiniMoka>(iter)?.finish(),
-            #[cfg(feature = "services-moka")]
-            services::MOKA_SCHEME => Self::from_iter::<services::Moka>(iter)?.finish(),
-            #[cfg(feature = "services-mongodb")]
-            services::MONGODB_SCHEME => Self::from_iter::<services::Mongodb>(iter)?.finish(),
-            #[cfg(feature = "services-monoiofs")]
-            services::MONOIOFS_SCHEME => Self::from_iter::<services::Monoiofs>(iter)?.finish(),
-            #[cfg(feature = "services-mysql")]
-            services::MYSQL_SCHEME => Self::from_iter::<services::Mysql>(iter)?.finish(),
-            #[cfg(feature = "services-obs")]
-            services::OBS_SCHEME => Self::from_iter::<services::Obs>(iter)?.finish(),
-            #[cfg(feature = "services-onedrive")]
-            services::ONEDRIVE_SCHEME => Self::from_iter::<services::Onedrive>(iter)?.finish(),
-            #[cfg(feature = "services-oss")]
-            services::OSS_SCHEME => Self::from_iter::<services::Oss>(iter)?.finish(),
-            #[cfg(feature = "services-pcloud")]
-            services::PCLOUD_SCHEME => Self::from_iter::<services::Pcloud>(iter)?.finish(),
-            #[cfg(feature = "services-persy")]
-            services::PERSY_SCHEME => Self::from_iter::<services::Persy>(iter)?.finish(),
-            #[cfg(feature = "services-postgresql")]
-            services::POSTGRESQL_SCHEME => Self::from_iter::<services::Postgresql>(iter)?.finish(),
-            #[cfg(feature = "services-redb")]
-            services::REDB_SCHEME => Self::from_iter::<services::Redb>(iter)?.finish(),
-            #[cfg(feature = "services-redis")]
-            services::REDIS_SCHEME => Self::from_iter::<services::Redis>(iter)?.finish(),
-            #[cfg(feature = "services-rocksdb")]
-            services::ROCKSDB_SCHEME => Self::from_iter::<services::Rocksdb>(iter)?.finish(),
-            #[cfg(feature = "services-s3")]
-            services::S3_SCHEME => Self::from_iter::<services::S3>(iter)?.finish(),
-            #[cfg(feature = "services-seafile")]
-            services::SEAFILE_SCHEME => Self::from_iter::<services::Seafile>(iter)?.finish(),
-            #[cfg(feature = "services-sftp")]
-            services::SFTP_SCHEME => Self::from_iter::<services::Sftp>(iter)?.finish(),
-            #[cfg(feature = "services-sled")]
-            services::SLED_SCHEME => Self::from_iter::<services::Sled>(iter)?.finish(),
-            #[cfg(feature = "services-sqlite")]
-            services::SQLITE_SCHEME => Self::from_iter::<services::Sqlite>(iter)?.finish(),
-            #[cfg(feature = "services-surrealdb")]
-            services::SURREALDB_SCHEME => Self::from_iter::<services::Surrealdb>(iter)?.finish(),
-            #[cfg(feature = "services-swift")]
-            services::SWIFT_SCHEME => Self::from_iter::<services::Swift>(iter)?.finish(),
-            #[cfg(feature = "services-tikv")]
-            services::TIKV_SCHEME => Self::from_iter::<services::Tikv>(iter)?.finish(),
-            #[cfg(feature = "services-upyun")]
-            services::UPYUN_SCHEME => Self::from_iter::<services::Upyun>(iter)?.finish(),
-            #[cfg(feature = "services-vercel-artifacts")]
-            services::VERCEL_ARTIFACTS_SCHEME => {
-                Self::from_iter::<services::VercelArtifacts>(iter)?.finish()
-            }
-            #[cfg(feature = "services-vercel-blob")]
-            services::VERCEL_BLOB_SCHEME => Self::from_iter::<services::VercelBlob>(iter)?.finish(),
-            #[cfg(feature = "services-webdav")]
-            services::WEBDAV_SCHEME => Self::from_iter::<services::Webdav>(iter)?.finish(),
-            #[cfg(feature = "services-webhdfs")]
-            services::WEBHDFS_SCHEME => Self::from_iter::<services::Webhdfs>(iter)?.finish(),
-            #[cfg(feature = "services-yandex-disk")]
-            services::YANDEX_DISK_SCHEME => Self::from_iter::<services::YandexDisk>(iter)?.finish(),
-            v => {
-                return Err(Error::new(
-                    ErrorKind::Unsupported,
-                    "scheme is not enabled or supported",
-                )
-                .with_context("scheme", v));
-            }
-        };
-
-        Ok(op)
+        Operator::from_uri((scheme.as_ref(), iter))
     }
 
     /// Create a new layer with dynamic dispatch.
@@ -470,3 +327,16 @@ impl<A: Access> OperatorBuilder<A> {
         Operator::from_inner(Arc::new(ob.accessor) as Accessor)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::services;
+
+    #[test]
+    fn via_iter_delegates_to_registry() {
+        let op = Operator::via_iter(services::MEMORY_SCHEME, [])
+            .expect("memory scheme should be registered");
+        let _ = op;
+    }
+}
diff --git a/core/core/src/types/operator/registry.rs b/core/core/src/types/operator/registry.rs
index 4aedc77d7..d4dcf0f2a 100644
--- a/core/core/src/types/operator/registry.rs
+++ b/core/core/src/types/operator/registry.rs
@@ -77,28 +77,128 @@ impl OperatorRegistry {
 }
 
 fn register_builtin_services(registry: &OperatorRegistry) {
-    let _ = registry;
-
-    #[cfg(feature = "services-memory")]
-    registry.register::<crate::services::Memory>(crate::services::MEMORY_SCHEME);
-    #[cfg(feature = "services-fs")]
-    registry.register::<crate::services::Fs>(crate::services::FS_SCHEME);
-    #[cfg(feature = "services-s3")]
-    registry.register::<crate::services::S3>(crate::services::S3_SCHEME);
+    #[cfg(feature = "services-aliyun-drive")]
+    registry.register::<crate::services::AliyunDrive>(crate::services::ALIYUN_DRIVE_SCHEME);
+    #[cfg(feature = "services-alluxio")]
+    registry.register::<crate::services::Alluxio>(crate::services::ALLUXIO_SCHEME);
     #[cfg(feature = "services-azblob")]
     registry.register::<crate::services::Azblob>(crate::services::AZBLOB_SCHEME);
+    #[cfg(feature = "services-azdls")]
+    registry.register::<crate::services::Azdls>(crate::services::AZDLS_SCHEME);
+    #[cfg(feature = "services-azfile")]
+    registry.register::<crate::services::Azfile>(crate::services::AZFILE_SCHEME);
     #[cfg(feature = "services-b2")]
     registry.register::<crate::services::B2>(crate::services::B2_SCHEME);
+    #[cfg(feature = "services-cacache")]
+    registry.register::<crate::services::Cacache>(crate::services::CACACHE_SCHEME);
+    #[cfg(feature = "services-cloudflare-kv")]
+    registry.register::<crate::services::CloudflareKv>(crate::services::CLOUDFLARE_KV_SCHEME);
+    #[cfg(feature = "services-compfs")]
+    registry.register::<crate::services::Compfs>(crate::services::COMPFS_SCHEME);
     #[cfg(feature = "services-cos")]
     registry.register::<crate::services::Cos>(crate::services::COS_SCHEME);
+    #[cfg(feature = "services-d1")]
+    registry.register::<crate::services::D1>(crate::services::D1_SCHEME);
+    #[cfg(feature = "services-dashmap")]
+    registry.register::<crate::services::Dashmap>(crate::services::DASHMAP_SCHEME);
+    #[cfg(feature = "services-dbfs")]
+    registry.register::<crate::services::Dbfs>(crate::services::DBFS_SCHEME);
+    #[cfg(feature = "services-dropbox")]
+    registry.register::<crate::services::Dropbox>(crate::services::DROPBOX_SCHEME);
+    #[cfg(feature = "services-etcd")]
+    registry.register::<crate::services::Etcd>(crate::services::ETCD_SCHEME);
+    #[cfg(feature = "services-foundationdb")]
+    registry.register::<crate::services::Foundationdb>(crate::services::FOUNDATIONDB_SCHEME);
+    #[cfg(feature = "services-fs")]
+    registry.register::<crate::services::Fs>(crate::services::FS_SCHEME);
+    #[cfg(feature = "services-ftp")]
+    registry.register::<crate::services::Ftp>(crate::services::FTP_SCHEME);
     #[cfg(feature = "services-gcs")]
     registry.register::<crate::services::Gcs>(crate::services::GCS_SCHEME);
+    #[cfg(feature = "services-gdrive")]
+    registry.register::<crate::services::Gdrive>(crate::services::GDRIVE_SCHEME);
+    #[cfg(feature = "services-ghac")]
+    registry.register::<crate::services::Ghac>(crate::services::GHAC_SCHEME);
+    #[cfg(feature = "services-github")]
+    registry.register::<crate::services::Github>(crate::services::GITHUB_SCHEME);
+    #[cfg(feature = "services-gridfs")]
+    registry.register::<crate::services::Gridfs>(crate::services::GRIDFS_SCHEME);
+    #[cfg(feature = "services-hdfs")]
+    registry.register::<crate::services::Hdfs>(crate::services::HDFS_SCHEME);
+    #[cfg(feature = "services-hdfs-native")]
+    registry.register::<crate::services::HdfsNative>(crate::services::HDFS_NATIVE_SCHEME);
+    #[cfg(feature = "services-http")]
+    registry.register::<crate::services::Http>(crate::services::HTTP_SCHEME);
+    #[cfg(feature = "services-huggingface")]
+    registry.register::<crate::services::Huggingface>(crate::services::HUGGINGFACE_SCHEME);
+    #[cfg(feature = "services-ipfs")]
+    registry.register::<crate::services::Ipfs>(crate::services::IPFS_SCHEME);
+    #[cfg(feature = "services-ipmfs")]
+    registry.register::<crate::services::Ipmfs>(crate::services::IPMFS_SCHEME);
+    #[cfg(feature = "services-koofr")]
+    registry.register::<crate::services::Koofr>(crate::services::KOOFR_SCHEME);
+    #[cfg(feature = "services-lakefs")]
+    registry.register::<crate::services::Lakefs>(crate::services::LAKEFS_SCHEME);
+    #[cfg(feature = "services-memcached")]
+    registry.register::<crate::services::Memcached>(crate::services::MEMCACHED_SCHEME);
+    #[cfg(feature = "services-memory")]
+    registry.register::<crate::services::Memory>(crate::services::MEMORY_SCHEME);
+    #[cfg(feature = "services-mini-moka")]
+    registry.register::<crate::services::MiniMoka>(crate::services::MINI_MOKA_SCHEME);
+    #[cfg(feature = "services-moka")]
+    registry.register::<crate::services::Moka>(crate::services::MOKA_SCHEME);
+    #[cfg(feature = "services-mongodb")]
+    registry.register::<crate::services::Mongodb>(crate::services::MONGODB_SCHEME);
+    #[cfg(feature = "services-monoiofs")]
+    registry.register::<crate::services::Monoiofs>(crate::services::MONOIOFS_SCHEME);
+    #[cfg(feature = "services-mysql")]
+    registry.register::<crate::services::Mysql>(crate::services::MYSQL_SCHEME);
     #[cfg(feature = "services-obs")]
     registry.register::<crate::services::Obs>(crate::services::OBS_SCHEME);
+    #[cfg(feature = "services-onedrive")]
+    registry.register::<crate::services::Onedrive>(crate::services::ONEDRIVE_SCHEME);
     #[cfg(feature = "services-oss")]
     registry.register::<crate::services::Oss>(crate::services::OSS_SCHEME);
+    #[cfg(feature = "services-pcloud")]
+    registry.register::<crate::services::Pcloud>(crate::services::PCLOUD_SCHEME);
+    #[cfg(feature = "services-persy")]
+    registry.register::<crate::services::Persy>(crate::services::PERSY_SCHEME);
+    #[cfg(feature = "services-postgresql")]
+    registry.register::<crate::services::Postgresql>(crate::services::POSTGRESQL_SCHEME);
+    #[cfg(feature = "services-redb")]
+    registry.register::<crate::services::Redb>(crate::services::REDB_SCHEME);
+    #[cfg(feature = "services-redis")]
+    registry.register::<crate::services::Redis>(crate::services::REDIS_SCHEME);
+    #[cfg(feature = "services-rocksdb")]
+    registry.register::<crate::services::Rocksdb>(crate::services::ROCKSDB_SCHEME);
+    #[cfg(feature = "services-s3")]
+    registry.register::<crate::services::S3>(crate::services::S3_SCHEME);
+    #[cfg(feature = "services-seafile")]
+    registry.register::<crate::services::Seafile>(crate::services::SEAFILE_SCHEME);
+    #[cfg(feature = "services-sftp")]
+    registry.register::<crate::services::Sftp>(crate::services::SFTP_SCHEME);
+    #[cfg(feature = "services-sled")]
+    registry.register::<crate::services::Sled>(crate::services::SLED_SCHEME);
+    #[cfg(feature = "services-sqlite")]
+    registry.register::<crate::services::Sqlite>(crate::services::SQLITE_SCHEME);
+    #[cfg(feature = "services-surrealdb")]
+    registry.register::<crate::services::Surrealdb>(crate::services::SURREALDB_SCHEME);
+    #[cfg(feature = "services-swift")]
+    registry.register::<crate::services::Swift>(crate::services::SWIFT_SCHEME);
+    #[cfg(feature = "services-tikv")]
+    registry.register::<crate::services::Tikv>(crate::services::TIKV_SCHEME);
     #[cfg(feature = "services-upyun")]
     registry.register::<crate::services::Upyun>(crate::services::UPYUN_SCHEME);
+    #[cfg(feature = "services-vercel-artifacts")]
+    registry.register::<crate::services::VercelArtifacts>(crate::services::VERCEL_ARTIFACTS_SCHEME);
+    #[cfg(feature = "services-vercel-blob")]
+    registry.register::<crate::services::VercelBlob>(crate::services::VERCEL_BLOB_SCHEME);
+    #[cfg(feature = "services-webdav")]
+    registry.register::<crate::services::Webdav>(crate::services::WEBDAV_SCHEME);
+    #[cfg(feature = "services-webhdfs")]
+    registry.register::<crate::services::Webhdfs>(crate::services::WEBHDFS_SCHEME);
+    #[cfg(feature = "services-yandex-disk")]
+    registry.register::<crate::services::YandexDisk>(crate::services::YANDEX_DISK_SCHEME);
 }
 
 /// Factory adapter that builds an operator from a configurator type.
diff --git a/core/core/src/types/operator/uri.rs b/core/core/src/types/operator/uri.rs
index 4a4e3bed3..1dd807dc4 100644
--- a/core/core/src/types/operator/uri.rs
+++ b/core/core/src/types/operator/uri.rs
@@ -41,20 +41,41 @@ impl OperatorUri {
         base: &str,
         extra_options: impl IntoIterator<Item = (String, String)>,
     ) -> Result<Self> {
+        let extra_opts = extra_options
+            .into_iter()
+            .map(|(k, v)| (k.to_ascii_lowercase(), v))
+            .collect::<Vec<_>>();
+
+        let mut options = HashMap::<String, String>::new();
+
+        // Allow pure scheme (e.g. "s3") to align with from_iter semantics.
+        if !base.contains("://") {
+            for (key, value) in &extra_opts {
+                options.insert(key.clone(), value.clone());
+            }
+            return Ok(Self {
+                scheme: base.to_ascii_lowercase(),
+                authority: None,
+                name: None,
+                username: None,
+                password: None,
+                root: None,
+                options,
+            });
+        }
+
         let url = Url::parse(base).map_err(|err| {
             Error::new(ErrorKind::ConfigInvalid, "failed to parse uri").set_source(err)
         })?;
 
         let scheme = url.scheme().to_ascii_lowercase();
 
-        let mut options = HashMap::<String, String>::new();
-
         for (key, value) in url.query_pairs() {
             options.insert(key.to_ascii_lowercase(), value.into_owned());
         }
 
-        for (key, value) in extra_options {
-            options.insert(key.to_ascii_lowercase(), value);
+        for (key, value) in extra_opts {
+            options.insert(key, value);
         }
 
         let username = if url.username().is_empty() {