Add _raw, _string, and generic variants to async module for parity with sync

Bring the async module to feature parity with the sync module by adding
missing endpoint variants that allow users to choose their response format:

- client.rs: Add request_impl_string for raw string HTTP responses
- http.rs: Add _string variants (global_info_string, global_info_with_resources_string,
  get_database_info_string, create_resource_string, read_resource_string,
  resource_history_string) and make global_info, global_info_with_resources,
  get_database_info generic over DeserializeOwned
- sirix.rs: Add info_raw, info_string, info_with_resources_raw,
  info_with_resources_string methods
- database.rs: Add info_raw, info_string methods
- resource.rs: Add create_raw, create (returning Value), create_string,
  read_string, read_with_metadata_string, history_string methods

https://claude.ai/code/session_01LgXiks4zqYLRVbkgmCNoGc

Author: claude

src/asynchronous/client.rs

@@ -95,6 +95,51 @@ pub async fn request_impl<T: DeserializeOwned>(
     }
 }
 
+pub async fn request_impl_string(
+    channel: Sender<Message>,
+    scheme: Scheme,
+    authority: Authority,
+    path_and_query: PathAndQuery,
+    method: Method,
+    headers: HeaderMap,
+    body: Body,
+) -> SirixResult<SirixResponse<String>> {
+    let uri = Uri::builder()
+        .scheme(scheme)
+        .authority(authority)
+        .path_and_query(path_and_query)
+        .build()
+        .unwrap();
+    // create request
+    let mut request_builder = Request::builder().uri(uri).method(method);
+    for header in headers {
+        request_builder = request_builder.header(header.0.unwrap(), header.1);
+    }
+    let request = request_builder.body(body).unwrap();
+    // create response channel
+    let (tx, rx) = oneshot::channel::<ResultResponse>();
+    // Perform request
+    let _ = channel
+        .send(Message {
+            request: request,
+            responder: tx,
+        })
+        .await;
+    let response = rx.await.unwrap().unwrap();
+    let status = response.status().clone();
+    let headers = response.headers().clone();
+    // Aggregate body
+    let body = body::aggregate(response).await?;
+    let mut buf: Vec<u8> = vec![];
+    std::io::Read::read_to_end(&mut body.reader(), &mut buf).unwrap();
+
+    Ok(SirixResponse {
+        headers: headers.to_owned(),
+        status: status,
+        body: String::from_utf8_lossy(&buf).into_owned(),
+    })
+}
+
 pub async fn request_impl_fire_no_response(
     channel: Sender<Message>,
     scheme: Scheme,

src/asynchronous/database.rs

@@ -3,10 +3,11 @@
 use super::super::info::TokenData;
 use super::super::types::{DbInfo, DbType, Json, Xml};
 use super::client::{Message, SirixResponse};
-use super::http::{create_database, delete_database, get_database_info};
+use super::http::{create_database, delete_database, get_database_info, get_database_info_string};
 use super::resource::Resource;
 use super::SirixResult;
 use hyper::http::uri::{Authority, Scheme};
+use serde::de::DeserializeOwned;
 use tokio::sync::mpsc::Sender;
 use tokio::sync::watch::Receiver;
 
@@ -30,6 +31,10 @@ pub struct Database<T> {
 
 impl<T> Database<T> {
     pub async fn info(&self) -> SirixResult<SirixResponse<DbInfo>> {
+        self.info_raw().await
+    }
+
+    pub async fn info_raw<U: DeserializeOwned>(&self) -> SirixResult<SirixResponse<U>> {
         match self.auth_channel.clone() {
             Some(watcher) => {
                 let token_data = watcher.borrow().as_ref().unwrap().clone();
@@ -56,6 +61,33 @@ impl<T> Database<T> {
         }
     }
 
+    pub async fn info_string(&self) -> SirixResult<SirixResponse<String>> {
+        match self.auth_channel.clone() {
+            Some(watcher) => {
+                let token_data = watcher.borrow().as_ref().unwrap().clone();
+                let token = token_data.token_type + " " + &token_data.access_token;
+                get_database_info_string(
+                    self.scheme.clone(),
+                    self.authority.clone(),
+                    &self.db_name,
+                    Some(&token),
+                    self.channel.clone(),
+                )
+                .await
+            }
+            None => {
+                get_database_info_string(
+                    self.scheme.clone(),
+                    self.authority.clone(),
+                    &self.db_name,
+                    None,
+                    self.channel.clone(),
+                )
+                .await
+            }
+        }
+    }
+
     pub async fn delete(&self) -> SirixResult<SirixResponse<()>> {
         match self.auth_channel.clone() {
             Some(watcher) => {