Enhance CacheClient to handle cache misses gracefully

- Updated the `get` method in CacheClient to return null for cache misses instead of throwing an error.
- Improved error handling to differentiate between expected 404 errors and other exceptions.
- Adjusted related tests to verify null returns for non-existent keys, ensuring robust cache behavior.

src/cache/client.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from "../core/http";
+import { SDKError } from "../errors";
 
 export interface CacheGetRequest {
   dmap: string;
@@ -67,12 +68,27 @@ export class CacheClient {
 
   /**
    * Get a value from cache
+   * Returns null if the key is not found (cache miss/expired), which is normal behavior
    */
-  async get(dmap: string, key: string): Promise<CacheGetResponse> {
+  async get(dmap: string, key: string): Promise<CacheGetResponse | null> {
-    return this.httpClient.post<CacheGetResponse>("/v1/cache/get", {
+    try {
-      dmap,
+      return await this.httpClient.post<CacheGetResponse>("/v1/cache/get", {
-      key,
+        dmap,
-    });
+        key,
+      });
+    } catch (error) {
+      // Cache misses (404 or "key not found" messages) are normal behavior - return null instead of throwing
+      if (
+        error instanceof SDKError &&
+        (error.httpStatus === 404 ||
+          (error.httpStatus === 500 &&
+            error.message?.toLowerCase().includes("key not found")))
+      ) {
+        return null;
+      }
+      // Re-throw other errors (network issues, server errors, etc.)
+      throw error;
+    }
   }
 
   /**

src/core/http.ts

@@ -152,11 +152,13 @@ export class HttpClient {
     } catch (error) {
       const duration = performance.now() - startTime;
       if (typeof console !== "undefined") {
-        // Cache "key not found" (404) is expected behavior - don't log as error
+        // Cache "key not found" (404 or error message) is expected behavior - don't log as error
         const isCacheGetNotFound =
           path === "/v1/cache/get" &&
           error instanceof SDKError &&
-          error.httpStatus === 404;
+          (error.httpStatus === 404 ||
+            (error.httpStatus === 500 &&
+              error.message?.toLowerCase().includes("key not found")));
 
         // "Not found" (404) for blocked_users is expected behavior - don't log as error
         // This happens when checking if users are blocked (most users aren't blocked)

tests/e2e/cache.test.ts

@@ -42,9 +42,10 @@ describe("Cache", () => {
 
     // Get value
     const getResult = await client.cache.get(testDMap, testKey);
-    expect(getResult.key).toBe(testKey);
+    expect(getResult).not.toBeNull();
-    expect(getResult.value).toBe(testValue);
+    expect(getResult!.key).toBe(testKey);
-    expect(getResult.dmap).toBe(testDMap);
+    expect(getResult!.value).toBe(testValue);
+    expect(getResult!.dmap).toBe(testDMap);
   });
 
   it("should put and get complex objects", async () => {
@@ -61,9 +62,10 @@ describe("Cache", () => {
 
     // Get object
     const getResult = await client.cache.get(testDMap, testKey);
-    expect(getResult.value).toBeDefined();
+    expect(getResult).not.toBeNull();
-    expect(getResult.value.name).toBe(testValue.name);
+    expect(getResult!.value).toBeDefined();
-    expect(getResult.value.age).toBe(testValue.age);
+    expect(getResult!.value.name).toBe(testValue.name);
+    expect(getResult!.value.age).toBe(testValue.age);
   });
 
   it("should put value with TTL", async () => {
@@ -82,7 +84,8 @@ describe("Cache", () => {
 
     // Verify value exists
     const getResult = await client.cache.get(testDMap, testKey);
-    expect(getResult.value).toBe(testValue);
+    expect(getResult).not.toBeNull();
+    expect(getResult!.value).toBe(testValue);
   });
 
   it("should delete a value", async () => {
@@ -95,20 +98,17 @@ describe("Cache", () => {
 
     // Verify it exists
     const before = await client.cache.get(testDMap, testKey);
-    expect(before.value).toBe(testValue);
+    expect(before).not.toBeNull();
+    expect(before!.value).toBe(testValue);
 
     // Delete value
     const deleteResult = await client.cache.delete(testDMap, testKey);
     expect(deleteResult.status).toBe("ok");
     expect(deleteResult.key).toBe(testKey);
 
-    // Verify it's deleted
+    // Verify it's deleted (should return null, not throw)
-    try {
+    const after = await client.cache.get(testDMap, testKey);
-      await client.cache.get(testDMap, testKey);
+    expect(after).toBeNull();
-      expect.fail("Expected get to fail after delete");
-    } catch (err: any) {
-      expect(err.message).toBeDefined();
-    }
   });
 
   it("should scan keys", async () => {
@@ -148,12 +148,9 @@ describe("Cache", () => {
     const client = await createTestClient();
     const nonExistentKey = "non-existent-key";
 
-    try {
+    // Cache misses should return null, not throw an error
-      await client.cache.get(testDMap, nonExistentKey);
+    const result = await client.cache.get(testDMap, nonExistentKey);
-      expect.fail("Expected get to fail for non-existent key");
+    expect(result).toBeNull();
-    } catch (err: any) {
-      expect(err.message).toBeDefined();
-    }
   });
 
   it("should handle empty dmap name", async () => {