@bunbase-ae/js 2.9.1-next.222.cb1adc4 → 2.9.1-next.225.44112ee

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunbase-ae/js",
-  "version": "2.9.1-next.222.cb1adc4",
+  "version": "2.9.1-next.225.44112ee",
   "type": "module",
   "description": "TypeScript/JavaScript SDK for BunBase",
   "license": "UNLICENSED",

package/src/http.ts

@@ -112,6 +112,34 @@ export class HttpClient {
       keepalive?: boolean;
     } = {},
   ): Promise<T> {
+    const res = await this.performWithRefresh(method, path, options);
+    return this.parse<T>(res);
+  }
+
+  // Returns the raw Response without parsing — for file downloads / blobs.
+  // Participates in the same 401 → refresh → retry flow as request<T>, and
+  // throws BunBaseError (with .status) on non-ok responses.
+  async requestRaw(method: string, path: string): Promise<Response> {
+    const res = await this.performWithRefresh(method, path, {});
+    if (!res.ok) throw await this.toError(res);
+    return res;
+  }
+
+  // Sends the request and, if the response is 401 and we hold a refresh token,
+  // refreshes once and retries. Returns the raw Response either way — the
+  // caller decides how to read/parse the body.
+  private async performWithRefresh(
+    method: string,
+    path: string,
+    options: {
+      body?: unknown;
+      formData?: FormData;
+      query?: Record<string, string>;
+      skipAuth?: boolean;
+      signal?: AbortSignal;
+      keepalive?: boolean;
+    },
+  ): Promise<Response> {
     const res = await this.send(method, path, options);
 
     // Static credentials (adminSecret, apiKey) don't use refresh tokens — skip the 401 retry flow.
@@ -128,26 +156,9 @@ export class HttpClient {
         // Refresh failed — tokens are already cleared in doRefresh.
         throw new BunBaseError("Session expired. Please log in again.", 401, null);
       }
-      const retried = await this.send(method, path, options);
-      return this.parse<T>(retried);
+      return this.send(method, path, options);
     }
 
-    return this.parse<T>(res);
-  }
-
-  // Returns the raw Response without parsing — for file downloads / blobs.
-  async requestRaw(method: string, path: string): Promise<Response> {
-    const res = await this.send(method, path, {});
-    if (!res.ok) {
-      let message = res.statusText;
-      try {
-        const data = (await res.clone().json()) as { error?: string };
-        if (data.error) message = data.error;
-      } catch {
-        // ignore
-      }
-      throw new Error(message);
-    }
     return res;
   }
 
@@ -206,18 +217,34 @@ export class HttpClient {
     const data = isJson ? await res.json() : await res.text();
 
     if (!res.ok) {
-      const body =
-        typeof data === "object" && data !== null ? (data as Record<string, unknown>) : {};
-      const message =
-        "error" in body ? String(body.error) : `Request failed with status ${res.status}`;
-      const code = "code" in body ? String(body.code) : undefined;
-      const field = "field" in body ? String(body.field) : undefined;
-      throw new BunBaseError(message, res.status, data, code, field);
+      throw this.buildError(res.status, data);
     }
 
     return data as T;
   }
 
+  // Builds a BunBaseError from a non-ok Response. Used by requestRaw, where
+  // the body is never parsed by the caller, so we read it here.
+  private async toError(res: Response): Promise<BunBaseError> {
+    const contentType = res.headers.get("content-type") ?? "";
+    const isJson = contentType.includes("application/json");
+    let data: unknown = null;
+    try {
+      data = isJson ? await res.clone().json() : await res.clone().text();
+    } catch {
+      // Body was empty or unreadable — fall back to status-based message.
+    }
+    return this.buildError(res.status, data);
+  }
+
+  private buildError(status: number, data: unknown): BunBaseError {
+    const body = typeof data === "object" && data !== null ? (data as Record<string, unknown>) : {};
+    const message = "error" in body ? String(body.error) : `Request failed with status ${status}`;
+    const code = "code" in body ? String(body.code) : undefined;
+    const field = "field" in body ? String(body.field) : undefined;
+    return new BunBaseError(message, status, data, code, field);
+  }
+
   // Deduplicated token refresh — multiple concurrent callers share one in-flight request.
   private doRefresh(): Promise<void> {
     if (this.refreshPromise) return this.refreshPromise;