ref: Revert client scope API

Author: jan-auer

clients/rust/src/client.rs

@@ -4,11 +4,9 @@ use std::time::Duration;
 
 use bytes::Bytes;
 use futures_util::stream::BoxStream;
-use objectstore_types::ExpirationPolicy;
+use objectstore_types::{Compression, ExpirationPolicy, scope};
 use url::Url;
 
-pub use objectstore_types::{Compression, scope as scope_types};
-
 const USER_AGENT: &str = concat!("objectstore-client/", env!("CARGO_PKG_VERSION"));
 
 #[derive(Debug)]
@@ -205,20 +203,20 @@ impl Usecase {
     }
 
     /// Creates a new [`Scope`] tied to the given organization.
-    pub fn for_organization(&self, organization: u64) -> crate::Result<Scope> {
+    pub fn for_organization(&self, organization: u64) -> Scope {
         Scope::for_organization(self.clone(), organization)
     }
 
     /// Creates a new [`Scope`] tied to the given organization and project.
-    pub fn for_project(&self, organization: u64, project: u64) -> crate::Result<Scope> {
+    pub fn for_project(&self, organization: u64, project: u64) -> Scope {
         Scope::for_project(self.clone(), organization, project)
     }
 }
 
 #[derive(Debug)]
 pub(crate) struct ScopeInner {
     usecase: Usecase,
-    scopes: scope_types::Scopes,
+    scopes: scope::Scopes,
 }
 
 impl ScopeInner {
@@ -260,28 +258,23 @@ impl Scope {
     pub fn new(usecase: Usecase) -> Self {
         Self(Ok(ScopeInner {
             usecase,
-            scopes: scope_types::Scopes::empty(),
+            scopes: scope::Scopes::empty(),
         }))
     }
 
-    fn for_organization(usecase: Usecase, organization: u64) -> crate::Result<Self> {
-        let scopes = scope_types::Scopes::from_iter([scope_types::Scope::create(
-            "org",
-            &organization.to_string(),
-        )?]);
-        Ok(Self(Ok(ScopeInner { usecase, scopes })))
+    fn for_organization(usecase: Usecase, organization: u64) -> Self {
+        Self::new(usecase).push("org", organization)
     }
 
-    fn for_project(usecase: Usecase, organization: u64, project: u64) -> crate::Result<Self> {
-        let scopes = scope_types::Scopes::from_iter([
-            scope_types::Scope::create("org", &organization.to_string())?,
-            scope_types::Scope::create("project", &project.to_string())?,
-        ]);
-        Ok(Self(Ok(ScopeInner { usecase, scopes })))
+    fn for_project(usecase: Usecase, organization: u64, project: u64) -> Self {
+        Self::for_organization(usecase, organization).push("project", project)
     }
 
     /// Extends this Scope by creating a new sub-scope nested within it.
-    pub fn push(self, key: &str, value: &str) -> Self {
+    pub fn push<V>(self, key: &str, value: V) -> Self
+    where
+        V: std::fmt::Display,
+    {
         let result = self.0.and_then(|mut inner| {
             inner.scopes.push(key, value)?;
             Ok(inner)
@@ -434,7 +427,6 @@ mod tests {
         let usecase = Usecase::new("testing");
         let scope = usecase
             .for_project(12345, 1337)
-            .unwrap()
             .push("app_slug", "email_app");
         let session = client.session(scope).unwrap();
 
@@ -448,7 +440,7 @@ mod tests {
     fn test_object_url_with_base_path() {
         let client = Client::new("http://127.0.0.1:8888/api/prefix").unwrap();
         let usecase = Usecase::new("testing");
-        let scope = usecase.for_project(12345, 1337).unwrap();
+        let scope = usecase.for_project(12345, 1337);
         let session = client.session(scope).unwrap();
 
         assert_eq!(

clients/rust/tests/e2e.rs

@@ -8,8 +8,7 @@ async fn stores_uncompressed() {
 
     let client = Client::builder(server.url("/")).build().unwrap();
     let usecase = Usecase::new("usecase");
-    let scope = usecase.for_organization(12345).unwrap();
-    let session = client.session(scope).unwrap();
+    let session = client.session(usecase.for_organization(12345)).unwrap();
 
     let body = "oh hai!";
 
@@ -35,8 +34,7 @@ async fn uses_zstd_by_default() {
 
     let client = Client::builder(server.url("/")).build().unwrap();
     let usecase = Usecase::new("usecase");
-    let scope = usecase.for_organization(12345).unwrap();
-    let session = client.session(scope).unwrap();
+    let session = client.session(usecase.for_organization(12345)).unwrap();
 
     let body = "oh hai!";
     let stored_id = session.put(body).send().await.unwrap().key;
@@ -64,8 +62,7 @@ async fn deletes_stores_stuff() {
 
     let client = Client::builder(server.url("/")).build().unwrap();
     let usecase = Usecase::new("usecase");
-    let scope = usecase.for_project(12345, 1337).unwrap();
-    let session = client.session(scope).unwrap();
+    let session = client.session(usecase.for_project(12345, 1337)).unwrap();
 
     let body = "oh hai!";
     let stored_id = session.put(body).send().await.unwrap().key;
@@ -82,8 +79,7 @@ async fn stores_under_given_key() {
 
     let client = Client::builder(server.url("/")).build().unwrap();
     let usecase = Usecase::new("usecase");
-    let scope = usecase.for_project(12345, 1337).unwrap();
-    let session = client.session(scope).unwrap();
+    let session = client.session(usecase.for_project(12345, 1337)).unwrap();
 
     let body = "oh hai!";
     let request = session.put(body).key("test-key123!!");
@@ -98,8 +94,7 @@ async fn overwrites_existing_key() {
 
     let client = Client::builder(server.url("/")).build().unwrap();
     let usecase = Usecase::new("usecase");
-    let scope = usecase.for_project(12345, 1337).unwrap();
-    let session = client.session(scope).unwrap();
+    let session = client.session(usecase.for_project(12345, 1337)).unwrap();
 
     let stored_id = session.put("initial body").send().await.unwrap().key;
     let request = session.put("new body").key(&stored_id);

objectstore-types/src/scope.rs

@@ -38,14 +38,18 @@ impl Scope {
     /// let invalid_scope = Scope::create("", "value");
     /// assert!(invalid_scope.is_err());
     /// ```
-    pub fn create(name: &str, value: &str) -> Result<Self, InvalidScopeError> {
+    pub fn create<V>(name: &str, value: V) -> Result<Self, InvalidScopeError>
+    where
+        V: std::fmt::Display,
+    {
+        let value = value.to_string();
         if name.is_empty() || value.is_empty() {
             return Err(InvalidScopeError);
         }
 
         Ok(Self {
             name: name.to_owned(),
-            value: value.to_owned(),
+            value,
         })
     }
 
@@ -100,7 +104,10 @@ impl Scopes {
     }
 
     /// Pushes a new scope to the collection.
-    pub fn push(&mut self, key: &str, value: &str) -> Result<(), InvalidScopeError> {
+    pub fn push<V>(&mut self, key: &str, value: V) -> Result<(), InvalidScopeError>
+    where
+        V: std::fmt::Display,
+    {
         self.scopes.push(Scope::create(key, value)?);
         Ok(())
     }

stresstest/src/http.rs

@@ -84,9 +84,9 @@ impl HttpRemote {
     fn session(&self, usecase: &Usecase, organization_id: u64) -> Session {
         // NB: Reuse the organization ID as project ID to create unique projects. Right now, we do
         // not benefit from simulating multiple projects per org.
-        let scope = usecase
+        usecase
             .for_project(organization_id, organization_id)
-            .unwrap();
-        self.client.session(scope).unwrap()
+            .session(&self.client)
+            .unwrap()
     }
 }