@go-avro/avro-js 0.0.2-beta.80 → 0.0.2-beta.81

package/dist/client/QueryClient.d.ts

@@ -17,6 +17,7 @@ declare module '../client/QueryClient' {
         _xhr<T>(method: string, path: string, body: any, cancelToken?: CancelToken, headers?: Record<string, string>, isIdempotent?: boolean, retryCount?: number, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
         _fetch<T>(method: string, path: string, body: any, cancelToken?: CancelToken, headers?: Record<string, string>, isIdempotent?: boolean, retryCount?: number): Promise<T>;
         getDelay(strategy: RetryStrategy, attempt: number): number;
+        sleep(ms: number): Promise<void>;
         useGetRoot(): UseQueryResult<ApiInfo, StandardError>;
         useGetJobs(companyGuid: string, body: {
             amt?: number;

package/dist/client/QueryClient.js

@@ -104,7 +104,7 @@ export class AvroQueryClient {
         const queryClient = useQueryClient();
         return useMutation({
             mutationFn: async ({ token, cancelToken }) => {
-                const resp = await this._fetch('POST', `/google/authorize?token=${token}`, {}, cancelToken, { 'Content-Type': 'application/json' });
+                const resp = await this._xhr('POST', `/google/authorize?token=${token}`, {}, cancelToken, { 'Content-Type': 'application/json' });
                 if (!resp || !('access_token' in resp)) {
                     if (resp.msg === "TOTP email sent") {
                         return LoginResponse.NEEDS_TOTP;
@@ -123,7 +123,7 @@ export class AvroQueryClient {
             },
             onError: (err) => {
                 this.config.authManager.clearTokens();
-                throw new StandardError(401, err.message || 'Google Login failed');
+                throw new StandardError(err.status, err.message || 'Google Login failed');
             }
         });
     }

package/dist/client/core/fetch.js

@@ -1,67 +1,63 @@
 import { AvroQueryClient } from '../../client/QueryClient';
 import { StandardError } from '../../types/error';
-AvroQueryClient.prototype._fetch = function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
+AvroQueryClient.prototype._fetch = async function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
     const checkCancelled = () => {
         try {
             if (cancelToken?.isCancelled()) {
-                return new StandardError(0, 'Request cancelled');
+                throw new StandardError(0, 'Request cancelled');
             }
         }
         catch (error) {
-            throw new StandardError(0, `Error checking cancellation (${typeof cancelToken}): ${error}`);
+            throw new StandardError(0, `Error checking cancellation: ${error.message}`);
         }
-        return null;
     };
-    return this.config.authManager.accessToken().then(token => {
-        const cancelErr = checkCancelled();
-        if (cancelErr)
-            return Promise.reject(cancelErr);
+    try {
+        checkCancelled();
+        const token = await this.config.authManager.accessToken();
+        checkCancelled();
         const url = this.config.baseUrl + path;
         const requestHeaders = {
             'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
             ...headers,
         };
-        if (token) {
-            requestHeaders['Authorization'] = `Bearer ${token}`;
-        }
         const options = {
             method,
             headers: requestHeaders,
-            body: body ? JSON.stringify(body) : null,
+            body: body ? JSON.stringify(body) : undefined,
         };
-        return fetch(url, options).then(response => {
-            if (response.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
-                return this.config.authManager
-                    .refreshTokens()
-                    .then(() => this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1))
-                    .catch(() => Promise.reject(new StandardError(401, 'Unauthorized (refresh failed)')));
-            }
-            if (!response.ok) {
-                if (retryCount < this.config.maxRetries) {
-                    const delay = this.getDelay(this.config.retryStrategy, retryCount);
-                    return new Promise((resolve, reject) => {
-                        setTimeout(() => {
-                            this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1)
-                                .then(resolve)
-                                .catch(reject);
-                        }, delay);
-                    });
-                }
-                else {
-                    return response.text().then(text => {
-                        let msg = response.statusText;
-                        try {
-                            const parsed = JSON.parse(text);
-                            msg = parsed.message || msg;
-                        }
-                        catch {
-                            console.warn('Failed to parse error response:', text);
-                        }
-                        throw new StandardError(response.status, msg);
-                    });
-                }
+        const response = await fetch(url, options);
+        if (response.ok) {
+            const text = await response.text();
+            if (!text) {
+                return undefined;
             }
-            return response.json();
-        });
-    });
+            return JSON.parse(text);
+        }
+        if (response.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
+            await this.config.authManager.refreshTokens();
+            return this._fetch(method, path, body, cancelToken, headers, isIdempotent, 1);
+        }
+        if (retryCount < this.config.maxRetries) {
+            const delay = this.getDelay(this.config.retryStrategy, retryCount);
+            await this.sleep(delay);
+            return this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1);
+        }
+        let errorMessage = response.statusText;
+        try {
+            const parsedError = await response.json();
+            errorMessage = parsedError.message ?? parsedError.msg ?? errorMessage;
+        }
+        catch (e) {
+            console.error('Ignoring:', e);
+        }
+        throw new StandardError(response.status, errorMessage);
+    }
+    catch (error) {
+        if (error instanceof StandardError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new StandardError(0, `Request failed: ${message}`);
+    }
 };

package/dist/client/core/utils.js

@@ -11,3 +11,4 @@ AvroQueryClient.prototype.getDelay = function (strategy, attempt) {
     }
     throw new Error(`Invalid retry strategy: ${strategy}`);
 };
+AvroQueryClient.prototype.sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

package/dist/client/core/xhr.js

@@ -1,87 +1,84 @@
 import { AvroQueryClient } from '../../client/QueryClient';
 import { StandardError } from '../../types/error';
-AvroQueryClient.prototype._xhr = function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0, progressUpdateCallback) {
+AvroQueryClient.prototype._xhr = async function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0, progressUpdateCallback) {
     const checkCancelled = () => {
         if (cancelToken?.isCancelled()) {
-            return new StandardError(0, 'Request cancelled');
+            throw new StandardError(0, 'Request cancelled');
         }
-        return null;
     };
-    return new Promise((resolve, reject) => {
-        this.config.authManager.accessToken().then(token => {
-            const cancelErr = checkCancelled();
-            if (cancelErr)
-                return reject(cancelErr);
-            const xhr = new XMLHttpRequest();
-            const url = this.config.baseUrl + path;
-            xhr.open(method, url, true);
-            if (token)
-                xhr.setRequestHeader('Authorization', `Bearer ${token}`);
-            Object.entries(headers).forEach(([key, value]) => xhr.setRequestHeader(key, value));
-            xhr.onload = () => {
-                const cancelErr = checkCancelled();
-                if (cancelErr)
-                    return reject(cancelErr);
-                if (xhr.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
-                    this.config.authManager
-                        .refreshTokens()
-                        .then(() => {
-                        this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                    })
-                        .catch(() => reject(new StandardError(401, 'Unauthorized (refresh failed)')));
-                    return;
-                }
-                if (xhr.status >= 200 && xhr.status < 300) {
-                    try {
-                        resolve(JSON.parse(xhr.responseText));
-                    }
-                    catch {
-                        resolve(xhr.responseText);
-                    }
-                }
-                else {
-                    if (retryCount < this.config.maxRetries) {
-                        const delay = this.getDelay(this.config.retryStrategy, retryCount);
-                        setTimeout(() => {
-                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                        }, delay);
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+        try {
+            checkCancelled();
+            const token = await this.config.authManager.accessToken();
+            checkCancelled();
+            const result = await new Promise((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                const url = this.config.baseUrl + path;
+                xhr.open(method, url, true);
+                if (token)
+                    xhr.setRequestHeader('Authorization', `Bearer ${token}`);
+                Object.entries(headers).forEach(([key, value]) => xhr.setRequestHeader(key, value));
+                xhr.onload = () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        try {
+                            const responseText = xhr.responseText;
+                            if (!responseText) {
+                                return resolve(undefined);
+                            }
+                            resolve(JSON.parse(responseText));
+                        }
+                        catch (e) {
+                            reject(new StandardError(0, `Failed to parse successful response: ${e.message}`));
+                        }
                     }
                     else {
-                        let msg = xhr.statusText;
+                        let msg = xhr.responseText || xhr.statusText;
                         try {
                             const parsed = JSON.parse(xhr.responseText);
-                            msg = parsed.msg || msg;
+                            msg = parsed.message ?? parsed.msg ?? msg;
                         }
-                        catch {
-                            console.warn('Failed to parse error response:', xhr.responseText);
+                        catch (e) {
+                            console.error('Ignoring:', e);
                         }
                         reject(new StandardError(xhr.status, msg));
                     }
-                }
-            };
-            if (progressUpdateCallback && xhr.upload) {
-                xhr.upload.onprogress = (event) => {
-                    if (event.lengthComputable) {
-                        progressUpdateCallback(event.loaded, event.total);
-                    }
                 };
+                xhr.onerror = () => reject(new StandardError(0, 'Network Error'));
+                if (this.config.timeout) {
+                    xhr.timeout = this.config.timeout;
+                    xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
+                }
+                if (progressUpdateCallback && xhr.upload) {
+                    xhr.upload.onprogress = (event) => {
+                        if (event.lengthComputable) {
+                            progressUpdateCallback(event.loaded, event.total);
+                        }
+                    };
+                }
+                xhr.send(body);
+            });
+            return result;
+        }
+        catch (error) {
+            if (!(error instanceof StandardError)) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new StandardError(0, `An unexpected error occurred: ${message}`);
             }
-            xhr.onerror = () => {
-                if (retryCount < this.config.maxRetries) {
-                    const delay = this.getDelay(this.config.retryStrategy, retryCount);
-                    setTimeout(() => {
-                        this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                    }, delay);
+            if (error.status === 401 && this.config.authManager.refreshTokens && attempt === 0) {
+                try {
+                    await this.config.authManager.refreshTokens();
+                    continue;
                 }
-                else {
-                    reject(new StandardError(0, 'Network Error'));
+                catch (refreshError) {
+                    throw new StandardError(401, 'Unauthorized (refresh failed)');
                 }
-            };
-            if (this.config.timeout) {
-                xhr.timeout = this.config.timeout;
-                xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
             }
-            xhr.send(body);
-        });
-    });
+            if (attempt >= this.config.maxRetries) {
+                throw error;
+            }
+            const delay = this.getDelay(this.config.retryStrategy, attempt);
+            await this.sleep(delay);
+        }
+    }
+    throw new StandardError(0, 'Request failed after maximum retries.');
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-avro/avro-js",
-  "version": "0.0.2-beta.80",
+  "version": "0.0.2-beta.81",
   "description": "JS client for Avro backend integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",