@bunbase-ae/js 2.9.1-next.222.cb1adc4 → 2.9.1-next.228.75fefb5

package/package.json

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

package/src/admin.ts

@@ -296,6 +296,19 @@ export interface ServerSettings {
   // a destinations list from the legacy fields at runtime — the Studio UI uses
   // this to drive a per-destination editor with explicit retention.
   backup_destinations?: BackupDestinationConfig[];
+  // Phase 1 (#350): when true, every backup also captures `_files` blobs as a
+  // content-addressed sibling tree. Default true — disable for very large
+  // storage tiers handled out-of-band (e.g. S3 versioning).
+  backup_include_storage?: boolean;
+  // Phase 2 (#350): when true, every backup also captures an AES-256-GCM
+  // encrypted bundle of secret env vars under `backup_env_passphrase`.
+  // Default false — opt-in. Passphrase loss is unrecoverable for the env
+  // restore path; DB+storage still restore without it.
+  backup_include_env?: boolean;
+  // Operator-provided passphrase for `backup_include_env`. Must be at least
+  // 32 chars. Returned as the redacted sentinel ("********") on read once
+  // #379 lands.
+  backup_env_passphrase?: string;
   server_timezone?: string;
   server_locale?: string;
   access_log_level?: "info" | "warn" | "error";
@@ -340,6 +353,12 @@ export interface BackupFile {
   sha256?: string;
   /** Per-destination push results. Only populated for newly-created backups. */
   destinations?: Array<{ id: string; type: string; ok: boolean; error?: string }>;
+  /**
+   * Whether an encrypted env bundle sidecar (`<filename>.env.json.enc`) is
+   * present alongside the dump. When true, the Studio Restore flow prompts
+   * for the env passphrase before calling restore. (#350 Phase 2)
+   */
+  has_env_bundle?: boolean;
 }
 
 export interface HealthResponse {
@@ -941,11 +960,11 @@ class AdminBackupsClient {
     await this.http.request("DELETE", `/api/v1/admin/backups/${encodeURIComponent(filename)}`);
   }
 
-  async restore(filename: string): Promise<void> {
+  async restore(filename: string, opts?: { env_passphrase?: string }): Promise<void> {
     await this.http.request(
       "POST",
       `/api/v1/admin/backups/${encodeURIComponent(filename)}/restore`,
-      { body: {} },
+      { body: opts ?? {} },
     );
   }
 

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;