get-db9 0.4.1 → 0.5.0

package/dist/client.cjs

@@ -84,6 +84,9 @@ var Db9ConflictError = class extends Db9Error {
 };
 
 // src/http.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function createHttpClient(options) {
   const fetchFn = options.fetch ?? globalThis.fetch;
   const baseUrl = options.baseUrl.replace(/\/$/, "");
@@ -92,38 +95,61 @@ function createHttpClient(options) {
     if (params) {
       const searchParams = new URLSearchParams();
       for (const [key, value] of Object.entries(params)) {
-        if (value !== void 0) {
-          searchParams.set(key, value);
-        }
+        if (value !== void 0) searchParams.set(key, value);
       }
       const qs = searchParams.toString();
       if (qs) url += `?${qs}`;
     }
-    const headers = {
+    const reqHeaders = {
       "Content-Type": "application/json",
       ...options.headers
     };
-    const init = { method, headers };
+    const init = { method, headers: reqHeaders };
     if (body !== void 0) {
       init.body = JSON.stringify(body);
     }
-    const response = await fetchFn(url, init);
-    if (!response.ok) {
-      throw await Db9Error.fromResponse(response);
-    }
-    if (response.status === 204) {
-      return void 0;
+    const maxAttempts = Math.min(options.maxRetries ?? 0, 3) + 1;
+    const baseDelay = options.retryDelay ?? 1e3;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      let timeoutId;
+      try {
+        const fetchInit = { ...init };
+        if (options.timeout) {
+          const controller = new AbortController();
+          fetchInit.signal = controller.signal;
+          timeoutId = setTimeout(() => controller.abort(), options.timeout);
+        }
+        const response = await fetchFn(url, fetchInit);
+        if (timeoutId) clearTimeout(timeoutId);
+        if (!response.ok) {
+          if (response.status >= 500 && attempt < maxAttempts - 1) {
+            lastError = await Db9Error.fromResponse(response);
+            await delay(baseDelay * Math.pow(2, attempt));
+            continue;
+          }
+          throw await Db9Error.fromResponse(response);
+        }
+        if (response.status === 204) return void 0;
+        return response.json();
+      } catch (err) {
+        if (timeoutId) clearTimeout(timeoutId);
+        if (err instanceof TypeError && attempt < maxAttempts - 1) {
+          lastError = err;
+          await delay(baseDelay * Math.pow(2, attempt));
+          continue;
+        }
+        throw err;
+      }
     }
-    return response.json();
+    throw lastError;
   }
   async function requestRaw(method, path, body, params, customHeaders) {
     let url = `${baseUrl}${path}`;
     if (params) {
       const searchParams = new URLSearchParams();
       for (const [key, value] of Object.entries(params)) {
-        if (value !== void 0) {
-          searchParams.set(key, value);
-        }
+        if (value !== void 0) searchParams.set(key, value);
       }
       const qs = searchParams.toString();
       if (qs) url += `?${qs}`;
@@ -132,15 +158,23 @@ function createHttpClient(options) {
       ...options.headers,
       ...customHeaders
     };
-    const init = { method, headers };
-    if (body !== void 0) {
-      init.body = body;
+    const fetchInit = { method, headers };
+    if (body !== void 0) fetchInit.body = body;
+    let timeoutId;
+    if (options.timeout) {
+      const controller = new AbortController();
+      fetchInit.signal = controller.signal;
+      timeoutId = setTimeout(() => controller.abort(), options.timeout);
     }
-    const response = await fetchFn(url, init);
-    if (!response.ok) {
-      throw await Db9Error.fromResponse(response);
+    try {
+      const response = await fetchFn(url, fetchInit);
+      if (timeoutId) clearTimeout(timeoutId);
+      if (!response.ok) throw await Db9Error.fromResponse(response);
+      return response;
+    } catch (err) {
+      if (timeoutId) clearTimeout(timeoutId);
+      throw err;
     }
-    return response;
   }
   return {
     get: (path, params) => request("GET", path, void 0, params),
@@ -148,7 +182,9 @@ function createHttpClient(options) {
     put: (path, body) => request("PUT", path, body),
     del: (path) => request("DELETE", path),
     getRaw: (path, params) => requestRaw("GET", path, void 0, params),
-    putRaw: (path, body, headers) => requestRaw("PUT", path, body, void 0, headers)
+    putRaw: (path, body, headers) => requestRaw("PUT", path, body, void 0, headers),
+    postRaw: (path, body, headers) => requestRaw("POST", path, body, void 0, headers),
+    delRaw: (path, params) => requestRaw("DELETE", path, void 0, params)
   };
 }
 
@@ -251,7 +287,10 @@ function createDb9Client(options = {}) {
   const fetchFn = options.fetch ?? globalThis.fetch;
   const publicClient = createHttpClient({
     baseUrl,
-    fetch: options.fetch
+    fetch: options.fetch,
+    timeout: options.timeout,
+    maxRetries: options.maxRetries,
+    retryDelay: options.retryDelay
   });
   async function getAuthClient() {
     if (!token && !tokenLoaded) {
@@ -274,35 +313,118 @@ function createDb9Client(options = {}) {
     return createHttpClient({
       baseUrl,
       fetch: options.fetch,
-      headers: { Authorization: `Bearer ${token}` }
+      headers: { Authorization: `Bearer ${token}` },
+      timeout: options.timeout,
+      maxRetries: options.maxRetries,
+      retryDelay: options.retryDelay
     });
   }
+  let refreshPromise = null;
+  async function refreshAnonymousToken() {
+    const creds = await store.load();
+    if (!creds?.anonymous_id || !creds?.anonymous_secret) {
+      throw new Error("Not an anonymous session");
+    }
+    const resp = await publicClient.post(
+      "/customer/anonymous-refresh",
+      {
+        anonymous_id: creds.anonymous_id,
+        anonymous_secret: creds.anonymous_secret
+      }
+    );
+    token = resp.token;
+    await store.save({ ...creds, token: resp.token });
+  }
+  async function withAuthRetry(operation) {
+    const client = await getAuthClient();
+    try {
+      return await operation(client);
+    } catch (err) {
+      if (!(err instanceof Db9Error) || err.statusCode !== 401) {
+        throw err;
+      }
+      try {
+        if (!refreshPromise) {
+          refreshPromise = refreshAnonymousToken();
+        }
+        await refreshPromise;
+      } catch {
+        throw err;
+      } finally {
+        refreshPromise = null;
+      }
+      const newClient = await getAuthClient();
+      return operation(newClient);
+    }
+  }
   function deriveFs9Url(dbId) {
     const origin = baseUrl.replace(/\/api\/?$/, "");
     return `${origin}/fs9/${dbId}`;
   }
-  async function fsRequest(method, dbId, fsPath, body, contentType) {
+  function getFsClient(dbId) {
+    const fs9Base = deriveFs9Url(dbId) + "/api/v1";
+    return createHttpClient({
+      baseUrl: fs9Base,
+      fetch: options.fetch,
+      headers: token ? { Authorization: `Bearer ${token}` } : {},
+      timeout: options.timeout,
+      maxRetries: options.maxRetries,
+      retryDelay: options.retryDelay
+    });
+  }
+  async function withFsAuthRetry(dbId, operation) {
     if (!token && !tokenLoaded) {
       await getAuthClient();
     }
-    const fs9Url = deriveFs9Url(dbId);
-    const url = `${fs9Url}/api/v1${fsPath}`;
-    const headers = {};
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    if (body !== void 0) {
-      headers["Content-Type"] = contentType || "text/plain";
+    const client = getFsClient(dbId);
+    try {
+      return await operation(client);
+    } catch (err) {
+      if (!(err instanceof Db9Error) || err.statusCode !== 401) {
+        throw err;
+      }
+      try {
+        if (!refreshPromise) {
+          refreshPromise = refreshAnonymousToken();
+        }
+        await refreshPromise;
+      } catch {
+        throw err;
+      } finally {
+        refreshPromise = null;
+      }
+      const newClient = getFsClient(dbId);
+      return operation(newClient);
     }
-    const init = { method, headers };
-    if (body !== void 0) {
-      init.body = body;
+  }
+  function parseSqlError(raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && typeof parsed.message === "string") {
+        return parsed;
+      }
+    } catch {
     }
-    const response = await fetchFn(url, init);
-    if (!response.ok) {
-      throw await Db9Error.fromResponse(response);
+    const pgMatch = raw.match(/^(?:ERROR:\s*)?(.+?)(?:\s+DETAIL:\s+(.+?))?(?:\s+HINT:\s+(.+?))?(?:\s+\(SQLSTATE\s+(\w+)\))?$/s);
+    if (pgMatch && pgMatch[1]) {
+      const result = { message: pgMatch[1].trim() };
+      if (pgMatch[2]) result.detail = pgMatch[2].trim();
+      if (pgMatch[3]) result.hint = pgMatch[3].trim();
+      if (pgMatch[4]) result.code = pgMatch[4];
+      return result;
     }
-    return response;
+    return { message: raw };
+  }
+  async function fsStat(dbId, path) {
+    return withFsAuthRetry(
+      dbId,
+      (client) => client.get("/stat", { path })
+    );
+  }
+  async function fetchAnonymousSecret() {
+    return withAuthRetry(
+      (client) => client.post("/customer/anonymous-secret", {})
+    );
   }
   return {
     auth: {
@@ -317,195 +439,206 @@ function createDb9Client(options = {}) {
         req
       ),
       // Authenticated endpoints
-      me: async () => {
-        const client = await getAuthClient();
-        return client.get("/customer/me");
-      },
-      getAnonymousSecret: async () => {
-        const client = await getAuthClient();
-        return client.get(
-          "/customer/anonymous-secret"
-        );
+      me: async () => withAuthRetry(
+        (client) => client.get("/customer/me")
+      ),
+      getAnonymousSecret: () => {
+        return fetchAnonymousSecret();
       },
-      claim: async (req) => {
-        const client = await getAuthClient();
-        return client.post("/customer/claim", req);
+      claim: async (req) => withAuthRetry(
+        (client) => client.post("/customer/claim", req)
+      ),
+      ensureAnonymousSecret: async () => {
+        const creds = await store.load();
+        if (!creds?.anonymous_id || creds.anonymous_secret) {
+          return;
+        }
+        const resp = await fetchAnonymousSecret();
+        await store.save({
+          ...creds,
+          anonymous_secret: resp.anonymous_secret
+        });
       }
     },
     tokens: {
-      list: async () => {
-        const client = await getAuthClient();
-        return client.get("/customer/tokens");
-      },
-      revoke: async (tokenId) => {
-        const client = await getAuthClient();
-        return client.del(`/customer/tokens/${tokenId}`);
-      }
+      list: async () => withAuthRetry(
+        (client) => client.get("/customer/tokens")
+      ),
+      revoke: async (tokenId) => withAuthRetry(
+        (client) => client.del(`/customer/tokens/${tokenId}`)
+      ),
+      create: async (req) => withAuthRetry(
+        (client) => client.post("/customer/tokens", req)
+      )
     },
     databases: {
       // ── CRUD ──────────────────────────────────────────────────
-      create: async (req) => {
-        const client = await getAuthClient();
-        return client.post("/customer/databases", req);
-      },
-      list: async () => {
-        const client = await getAuthClient();
-        return client.get("/customer/databases");
-      },
-      get: async (databaseId) => {
-        const client = await getAuthClient();
-        return client.get(
+      create: async (req) => withAuthRetry(
+        (client) => client.post("/customer/databases", req)
+      ),
+      list: async () => withAuthRetry(
+        (client) => client.get("/customer/databases")
+      ),
+      get: async (databaseId) => withAuthRetry(
+        (client) => client.get(
           `/customer/databases/${databaseId}`
-        );
-      },
-      delete: async (databaseId) => {
-        const client = await getAuthClient();
-        return client.del(
+        )
+      ),
+      delete: async (databaseId) => withAuthRetry(
+        (client) => client.del(
           `/customer/databases/${databaseId}`
-        );
-      },
-      resetPassword: async (databaseId) => {
-        const client = await getAuthClient();
-        return client.post(
+        )
+      ),
+      resetPassword: async (databaseId) => withAuthRetry(
+        (client) => client.post(
           `/customer/databases/${databaseId}/reset-password`
-        );
-      },
-      observability: async (databaseId) => {
-        const client = await getAuthClient();
-        return client.get(
+        )
+      ),
+      observability: async (databaseId) => withAuthRetry(
+        (client) => client.get(
           `/customer/databases/${databaseId}/observability`
-        );
-      },
+        )
+      ),
       // ── SQL Execution ─────────────────────────────────────────
       sql: async (databaseId, query) => {
-        const client = await getAuthClient();
-        return client.post(
-          `/customer/databases/${databaseId}/sql`,
-          { query }
+        const result = await withAuthRetry(
+          (client) => client.post(
+            `/customer/databases/${databaseId}/sql`,
+            { query }
+          )
         );
+        if (result.error && typeof result.error === "string") {
+          result.error = parseSqlError(result.error);
+        }
+        return result;
       },
       sqlFile: async (databaseId, fileContent) => {
-        const client = await getAuthClient();
-        return client.post(
-          `/customer/databases/${databaseId}/sql`,
-          { file_content: fileContent }
+        const result = await withAuthRetry(
+          (client) => client.post(
+            `/customer/databases/${databaseId}/sql`,
+            { file_content: fileContent }
+          )
         );
+        if (result.error && typeof result.error === "string") {
+          result.error = parseSqlError(result.error);
+        }
+        return result;
       },
       // ── Schema & Dump ─────────────────────────────────────────
-      schema: async (databaseId) => {
-        const client = await getAuthClient();
-        return client.get(
+      schema: async (databaseId) => withAuthRetry(
+        (client) => client.get(
           `/customer/databases/${databaseId}/schema`
-        );
-      },
-      dump: async (databaseId, req) => {
-        const client = await getAuthClient();
-        return client.post(
+        )
+      ),
+      dump: async (databaseId, req) => withAuthRetry(
+        (client) => client.post(
           `/customer/databases/${databaseId}/dump`,
           req
-        );
-      },
+        )
+      ),
       // ── Migrations ────────────────────────────────────────────
-      applyMigration: async (databaseId, req) => {
-        const client = await getAuthClient();
-        return client.post(
+      applyMigration: async (databaseId, req) => withAuthRetry(
+        (client) => client.post(
           `/customer/databases/${databaseId}/migrations`,
           req
-        );
-      },
-      listMigrations: async (databaseId) => {
-        const client = await getAuthClient();
-        return client.get(
+        )
+      ),
+      listMigrations: async (databaseId) => withAuthRetry(
+        (client) => client.get(
           `/customer/databases/${databaseId}/migrations`
-        );
-      },
+        )
+      ),
       // ── Branching ─────────────────────────────────────────────
-      branch: async (databaseId, req) => {
-        const client = await getAuthClient();
-        return client.post(
+      branch: async (databaseId, req) => withAuthRetry(
+        (client) => client.post(
           `/customer/databases/${databaseId}/branch`,
           req
-        );
-      },
+        )
+      ),
       // ── User Management ───────────────────────────────────────
       users: {
-        list: async (databaseId) => {
-          const client = await getAuthClient();
-          return client.get(
+        list: async (databaseId) => withAuthRetry(
+          (client) => client.get(
             `/customer/databases/${databaseId}/users`
-          );
-        },
-        create: async (databaseId, req) => {
-          const client = await getAuthClient();
-          return client.post(
+          )
+        ),
+        create: async (databaseId, req) => withAuthRetry(
+          (client) => client.post(
             `/customer/databases/${databaseId}/users`,
             req
-          );
-        },
-        delete: async (databaseId, username) => {
-          const client = await getAuthClient();
-          return client.del(
+          )
+        ),
+        delete: async (databaseId, username) => withAuthRetry(
+          (client) => client.del(
             `/customer/databases/${databaseId}/users/${username}`
-          );
-        }
+          )
+        )
       }
     },
     fs: {
       list: async (dbId, path, options2) => {
-        const params = new URLSearchParams({ path });
-        if (options2?.recursive) params.set("recursive", "true");
-        const response = await fsRequest(
-          "GET",
+        const params = { path };
+        if (options2?.recursive) params.recursive = "true";
+        return withFsAuthRetry(
           dbId,
-          `/readdir?${params.toString()}`
+          (client) => client.get("/readdir", params)
         );
-        return response.json();
       },
       read: async (dbId, path) => {
-        const params = new URLSearchParams({ path });
-        const response = await fsRequest(
-          "GET",
-          dbId,
-          `/download?${params.toString()}`
-        );
-        return response.text();
+        return withFsAuthRetry(dbId, async (client) => {
+          const resp = await client.getRaw("/download", { path });
+          return resp.text();
+        });
       },
-      write: async (dbId, path, content) => {
-        const params = new URLSearchParams({ path });
-        await fsRequest("PUT", dbId, `/upload?${params.toString()}`, content);
+      readBinary: async (dbId, path) => {
+        return withFsAuthRetry(dbId, async (client) => {
+          const resp = await client.getRaw("/download", { path });
+          return resp.arrayBuffer();
+        });
       },
-      stat: async (dbId, path) => {
-        const params = new URLSearchParams({ path });
-        const response = await fsRequest(
-          "GET",
+      write: async (dbId, path, content) => {
+        const contentType = typeof content === "string" ? "text/plain" : "application/octet-stream";
+        await withFsAuthRetry(
           dbId,
-          `/stat?${params.toString()}`
+          (client) => client.putRaw(`/upload?${new URLSearchParams({ path })}`, content, { "Content-Type": contentType })
         );
-        return response.json();
+      },
+      stat: (dbId, path) => {
+        return fsStat(dbId, path);
+      },
+      exists: async (dbId, path) => {
+        try {
+          await fsStat(dbId, path);
+          return true;
+        } catch (err) {
+          if (err instanceof Db9Error && err.statusCode === 404) {
+            return false;
+          }
+          throw err;
+        }
       },
       mkdir: async (dbId, path) => {
-        const openResp = await fsRequest(
-          "POST",
+        await withFsAuthRetry(
           dbId,
-          "/open",
-          JSON.stringify({
-            path,
-            flags: { create: true, directory: true }
-          }),
-          "application/json"
+          (client) => client.postRaw(`/mkdir?${new URLSearchParams({ path, recursive: "true" })}`)
         );
-        const { handle_id } = await openResp.json();
-        await fsRequest(
-          "POST",
+      },
+      remove: async (dbId, path) => {
+        await withFsAuthRetry(
           dbId,
-          "/close",
-          JSON.stringify({ handle_id }),
-          "application/json"
+          (client) => client.delRaw("/remove", { path })
         );
       },
-      remove: async (dbId, path) => {
-        const params = new URLSearchParams({ path });
-        await fsRequest("DELETE", dbId, `/remove?${params.toString()}`);
+      events: async (dbId, options2) => {
+        const params = {};
+        if (options2?.limit !== void 0) params.limit = String(options2.limit);
+        if (options2?.offset !== void 0) params.offset = String(options2.offset);
+        if (options2?.path) params.path = options2.path;
+        if (options2?.type) params.type = options2.type;
+        return withFsAuthRetry(
+          dbId,
+          (client) => client.get("/events", params)
+        );
       }
     }
   };