@vuevox/sdk 0.3.0 → 0.5.0

package/dist/client.js

@@ -4,12 +4,15 @@ export function createVueVoxClient(options) {
     const baseUrl = trimTrailingSlash(options.baseUrl ?? "https://api.vuevox.com");
     const fetchFn = options.fetch ?? fetch;
     const raw = createClient({ baseUrl, fetch: fetchFn });
+    const retries = options.retries ?? 0;
+    const retryBaseDelayMs = options.retryBaseDelayMs ?? 250;
+    const retryMaxDelayMs = options.retryMaxDelayMs ?? 2_000;
     let cachedToken = null;
     async function getAccessToken() {
         if (cachedToken && Date.now() < cachedToken.expiresAt - 30_000) {
             return cachedToken.accessToken;
         }
-        const response = await fetchFn(`${baseUrl}/oauth/token`, {
+        const result = await requestJson("POST", "/oauth/token", {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -21,57 +24,95 @@ export function createVueVoxClient(options) {
                 scope: formatScope(options.scope),
             }),
         });
-        const body = await parseJson(response);
-        const requestId = getRequestId(response, body);
-        notifyResponse(options, "POST", "/oauth/token", response, requestId);
-        if (!response.ok) {
-            const error = isErrorResponse(body) ? body.error : null;
-            throw new VueVoxApiError(response.status, error?.code ?? "token_request_failed", error?.message ?? "VueVox token request failed.", isErrorResponse(body) ? body : undefined, requestId);
-        }
-        if (!isTokenResponse(body)) {
-            throw new VueVoxApiError(response.status, "invalid_token_response", "VueVox returned an invalid token response.", undefined, requestId);
-        }
+        const body = result.data;
         cachedToken = {
             accessToken: body.access_token,
             expiresAt: Date.now() + body.expires_in * 1000,
         };
         return cachedToken.accessToken;
     }
-    async function hello() {
-        const accessToken = await getAccessToken();
-        const { data, error, response } = await raw.GET("/v1/hello", {
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-            },
-        });
-        const requestId = getRequestId(response, error);
-        notifyResponse(options, "GET", "/v1/hello", response, requestId);
-        if (error) {
-            throw new VueVoxApiError(response.status, error.error.code, error.error.message, error, requestId);
-        }
-        return withMetadata(data, response, requestId);
+    async function getHello() {
+        return apiGet("/v1/hello");
     }
     async function listSpaces(listOptions = {}) {
+        return apiGet("/v1/spaces", listOptions);
+    }
+    async function listAgents(listOptions = {}) {
+        return apiGet("/v1/agents", listOptions);
+    }
+    async function listCalls(listOptions = {}) {
+        return apiGet("/v1/calls", listOptions);
+    }
+    async function getCall(callId) {
+        return apiGet(`/v1/calls/${encodeURIComponent(callId)}`);
+    }
+    async function listLeads(listOptions = {}) {
+        return apiGet("/v1/leads", listOptions);
+    }
+    async function getLead(leadId) {
+        return apiGet(`/v1/leads/${encodeURIComponent(leadId)}`);
+    }
+    async function apiGet(path, query) {
         const accessToken = await getAccessToken();
-        const { data, error, response } = await raw.GET("/v1/spaces", {
-            params: {
-                query: listOptions,
-            },
+        const result = await requestJson("GET", path, {
+            method: "GET",
             headers: {
                 Authorization: `Bearer ${accessToken}`,
             },
+            query,
         });
-        const requestId = getRequestId(response, error);
-        notifyResponse(options, "GET", "/v1/spaces", response, requestId);
-        if (error) {
-            throw new VueVoxApiError(response.status, error.error.code, error.error.message, error, requestId);
+        return withMetadata(result.data, result.response, result.requestId);
+    }
+    async function requestJson(method, path, init) {
+        for (let attempt = 0;; attempt++) {
+            const response = await fetchFn(buildUrl(baseUrl, path, init.query), init);
+            const body = await parseJson(response);
+            const requestId = getRequestId(response, body);
+            const retryAfter = retryAfterSeconds(response);
+            notifyResponse(options, method, path, response, requestId, retryAfter);
+            if (response.ok) {
+                if (body === null || isErrorResponse(body)) {
+                    throw new VueVoxApiError(response.status, "invalid_response", "VueVox returned an invalid response.", undefined, requestId, retryAfter);
+                }
+                return { data: body, requestId, response };
+            }
+            if (attempt < retries && shouldRetry(response.status)) {
+                await sleep(retryDelayMs(attempt, retryAfter));
+                continue;
+            }
+            const error = isErrorResponse(body) ? body.error : null;
+            throw new VueVoxApiError(response.status, error?.code ?? "api_request_failed", error?.message ?? "VueVox API request failed.", isErrorResponse(body) ? body : undefined, requestId, retryAfter);
+        }
+    }
+    function retryDelayMs(attempt, retryAfter) {
+        if (retryAfter !== undefined) {
+            return retryAfter * 1000;
         }
-        return withMetadata(data, response, requestId);
+        return Math.min(retryBaseDelayMs * 2 ** attempt, retryMaxDelayMs);
     }
     return {
         getAccessToken,
-        hello,
-        listSpaces,
+        hello: {
+            get: getHello,
+        },
+        spaces: {
+            list: listSpaces,
+            paginate: (listOptions = {}) => paginate(listSpaces, listOptions),
+        },
+        agents: {
+            list: listAgents,
+            paginate: (listOptions = {}) => paginate(listAgents, listOptions),
+        },
+        calls: {
+            list: listCalls,
+            get: getCall,
+            paginate: (listOptions = {}) => paginate(listCalls, listOptions),
+        },
+        leads: {
+            list: listLeads,
+            get: getLead,
+            paginate: (listOptions = {}) => paginate(listLeads, listOptions),
+        },
         raw,
     };
 }
@@ -84,6 +125,15 @@ function formatScope(scope) {
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/, "");
 }
+function buildUrl(baseUrl, path, query) {
+    const url = new URL(`${baseUrl}${path}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        if ((typeof value === "string" || typeof value === "number") && value !== "") {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return url.toString();
+}
 async function parseJson(response) {
     try {
         return (await response.json());
@@ -93,16 +143,19 @@ async function parseJson(response) {
     }
 }
 function isTokenResponse(value) {
-    return Boolean(value && "access_token" in value);
+    return isObject(value) && "access_token" in value;
 }
 function isErrorResponse(value) {
-    return Boolean(value && "error" in value);
+    return isObject(value) && "error" in value;
 }
 function getRequestId(response, body) {
     return response.headers.get("X-Request-Id") ?? (isErrorBody(body) ? body.error.requestId : undefined);
 }
 function isErrorBody(value) {
-    return Boolean(value && "error" in value);
+    return isObject(value) && "error" in value;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
 }
 function withMetadata(data, response, requestId) {
     return {
@@ -111,11 +164,40 @@ function withMetadata(data, response, requestId) {
         status: response.status,
     };
 }
-function notifyResponse(options, method, path, response, requestId) {
+function notifyResponse(options, method, path, response, requestId, retryAfter) {
     options.onResponse?.({
         method,
         path,
         requestId,
+        retryAfter,
         status: response.status,
     });
 }
+async function* paginate(list, listOptions) {
+    let cursor = listOptions.cursor;
+    do {
+        const response = await list({ ...listOptions, cursor });
+        for (const item of response.data.data) {
+            yield item;
+        }
+        cursor = response.data.pagination.nextCursor ?? undefined;
+    } while (cursor);
+}
+function shouldRetry(status) {
+    return [429, 500, 502, 503, 504].includes(status);
+}
+function retryAfterSeconds(response) {
+    const value = response.headers.get("Retry-After");
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds);
+    }
+    const timestamp = Date.parse(value);
+    return Number.isNaN(timestamp) ? undefined : Math.max(0, Math.ceil((timestamp - Date.now()) / 1000));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/errors.d.ts

@@ -3,7 +3,10 @@ export type VueVoxErrorResponse = components["schemas"]["ErrorResponse"];
 export declare class VueVoxApiError extends Error {
     readonly status: number;
     readonly code: string;
+    readonly details?: Record<string, unknown>;
+    readonly isRateLimited: boolean;
     readonly requestId?: string;
+    readonly retryAfter?: number;
     readonly response?: VueVoxErrorResponse;
-    constructor(status: number, code: string, message: string, response?: VueVoxErrorResponse, requestId?: string);
+    constructor(status: number, code: string, message: string, response?: VueVoxErrorResponse, requestId?: string, retryAfter?: number);
 }

package/dist/errors.js

@@ -1,14 +1,20 @@
 export class VueVoxApiError extends Error {
     status;
     code;
+    details;
+    isRateLimited;
     requestId;
+    retryAfter;
     response;
-    constructor(status, code, message, response, requestId) {
+    constructor(status, code, message, response, requestId, retryAfter) {
         super(message);
         this.name = "VueVoxApiError";
         this.status = status;
         this.code = code;
+        this.details = response?.error.details;
+        this.isRateLimited = status === 429 || code === "rate_limited";
         this.requestId = requestId ?? response?.error.requestId;
+        this.retryAfter = retryAfter;
         this.response = response;
     }
 }