let json serialization handle the base64 encode/decode

Author: roberto-bayardo

sdk-rs/src/store.rs

@@ -8,28 +8,12 @@ use serde::{Deserialize, Serialize};
 /// The JSON payload for a `get` operation response.
 #[derive(Serialize, Deserialize, Debug)]
 pub struct GetResultPayload {
-    pub value: String,
-}
-
-/// The result of a `get` operation.
-#[derive(Debug)]
-pub struct GetResult {
-    /// The retrieved value.
     pub value: Vec<u8>,
 }
 
-/// An item in the result of a `query` operation. For internal use.
+/// An item in the result of a `query` operation.
 #[derive(Serialize, Deserialize, Debug)]
 pub struct QueryResultItemPayload {
-    /// The key of the item (base64 encoded).
-    pub key: String,
-    /// The value of the item (base64 encoded).
-    pub value: String,
-}
-
-/// An item in the result of a `query` operation.
-#[derive(Debug)]
-pub struct QueryResultItem {
     /// The key of the item.
     pub key: Vec<u8>,
     /// The value of the item.
@@ -42,13 +26,6 @@ pub struct QueryResultPayload {
     pub results: Vec<QueryResultItemPayload>,
 }
 
-/// The result of a `query` operation.
-#[derive(Debug)]
-pub struct QueryResult {
-    /// A list of key-value pairs.
-    pub results: Vec<QueryResultItem>,
-}
-
 /// A client for interacting with the key-value store.
 #[derive(Clone)]
 pub struct Client {
@@ -90,7 +67,7 @@ impl Client {
     /// Retrieves a value from the store by its key.
     ///
     /// If the key does not exist, `Ok(None)` is returned.
-    pub async fn get(&self, key: &[u8]) -> Result<Option<GetResult>, Error> {
+    pub async fn get(&self, key: &[u8]) -> Result<Option<GetResultPayload>, Error> {
         let key_b64 = general_purpose::STANDARD.encode(key);
         let url = format!("{}/store/{}", self.client.base_url, key_b64);
         let mut headers = reqwest::header::HeaderMap::new();
@@ -116,9 +93,8 @@ impl Client {
         }
 
         let payload: GetResultPayload = res.json().await?;
-        let value = general_purpose::STANDARD.decode(payload.value)?;
 
-        Ok(Some(GetResult { value }))
+        Ok(Some(payload))
     }
 
     /// Queries for a range of key-value pairs.
@@ -133,7 +109,7 @@ impl Client {
         start: Option<&[u8]>,
         end: Option<&[u8]>,
         limit: Option<usize>,
-    ) -> Result<QueryResult, Error> {
+    ) -> Result<QueryResultPayload, Error> {
         let mut url = format!("{}/store?", self.client.base_url);
         if let Some(start) = start {
             let start_b64 = general_purpose::STANDARD.encode(start);
@@ -166,14 +142,7 @@ impl Client {
         }
 
         let payload: QueryResultPayload = res.json().await?;
-        let mut results = Vec::new();
-        for item in payload.results {
-            results.push(QueryResultItem {
-                key: general_purpose::STANDARD.decode(item.key)?,
-                value: general_purpose::STANDARD.decode(item.value)?,
-            });
-        }
 
-        Ok(QueryResult { results })
+        Ok(payload)
     }
 }

sdk-ts/__tests__/sdk.test.ts

@@ -38,21 +38,22 @@ describe('Exoware TS SDK', () => {
 
         it('should query for key-value pairs', async () => {
             const store = client.store();
+            const encoder = new TextEncoder();
             const prefix = 'query-test-';
             const pairs = [
-                { key: `${prefix}a`, value: Buffer.from('a') },
-                { key: `${prefix}b`, value: Buffer.from('b') },
-                { key: `${prefix}c`, value: Buffer.from('c') },
+                { key: encoder.encode(`${prefix}a`), value: Buffer.from('a') },
+                { key: encoder.encode(`${prefix}b`), value: Buffer.from('b') },
+                { key: encoder.encode(`${prefix}c`), value: Buffer.from('c') },
             ];
 
             for (const pair of pairs) {
-                await store.set(new TextEncoder().encode(pair.key), pair.value);
+                await store.set(pair.key, pair.value);
             }
 
-            const result = await store.query(`${prefix}a`, `${prefix}z`);
+            const result = await store.query(encoder.encode(`${prefix}a`), encoder.encode(`${prefix}z`));
             expect(result.results.length).toBe(3);
             expect(result.results.map(r => Buffer.from(r.value))).toEqual(pairs.map(p => p.value));
-            expect(result.results.map(r => new TextDecoder().decode(r.key)).sort()).toEqual(pairs.map(p => p.key).sort());
+            expect(result.results.map(r => r.key).sort()).toEqual(pairs.map(p => p.key).sort());
         });
 
         describe('limits', () => {

sdk-ts/src/store.ts

@@ -64,8 +64,8 @@ export class StoreClient {
         const encodedKey = Base64.fromUint8Array(key);
         const url = `${this.client.baseUrl}/store/${encodedKey}`;
         try {
-            const response = await this.client.httpClient.get<{ value: string }>(url);
-            const value = Base64.toUint8Array(response.data.value);
+            const response = await this.client.httpClient.get<{ value: number[] }>(url);
+            const value = new Uint8Array(response.data.value);
             return { value };
         } catch (error) {
             if (error instanceof AxiosError && error.response) {
@@ -97,10 +97,10 @@ export class StoreClient {
         if (limit) url.searchParams.append('limit', limit.toString());
 
         try {
-            const response = await this.client.httpClient.get<{ results: { key: string, value: string }[] }>(url.toString());
+            const response = await this.client.httpClient.get<{ results: { key: number[], value: number[] }[] }>(url.toString());
             const results = response.data.results.map(item => ({
-                key: Base64.toUint8Array(item.key),
-                value: Base64.toUint8Array(item.value),
+                key: new Uint8Array(item.key),
+                value: new Uint8Array(item.value)
             }));
             return { results };
         } catch (error) {

simulator/src/server/store/handlers.rs

@@ -140,7 +140,7 @@ pub(super) async fn get(
                     "get request completed successfully"
                 );
                 Ok(Json(GetResultPayload {
-                    value: general_purpose::STANDARD.encode(&stored_value.value),
+                    value: stored_value.value,
                 }))
             } else {
                 debug!(
@@ -210,8 +210,8 @@ pub(super) async fn query(
             }
 
             results.push(QueryResultItemPayload {
-                key: general_purpose::STANDARD.encode(&key),
-                value: general_purpose::STANDARD.encode(&stored_value.value),
+                key: key.to_vec(),
+                value: stored_value.value,
             });
         } else {
             warn!(