@go-avro/avro-js 0.0.2-beta.13 → 0.0.2-beta.131

package/dist/client/QueryClient.js

@@ -1,241 +1,281 @@
+import io from 'socket.io-client';
+import { useMutation } from '@tanstack/react-query';
+import { LoginResponse } from '../types/api';
 import { StandardError } from '../types/error';
 export class AvroQueryClient {
     constructor(config) {
+        this._isAuthenticated = false;
+        this.companyId = null;
+        this.company = null;
         this.config = {
             baseUrl: config.baseUrl,
             authManager: config.authManager,
+            queryClient: config.queryClient,
             maxRetries: config.maxRetries ?? 3,
             retryStrategy: config.retryStrategy ?? 'fixed',
             timeout: config.timeout ?? 0,
         };
-    }
-    getDelay(strategy, attempt) {
-        if (typeof strategy === 'function') {
-            return strategy(attempt);
-        }
-        else if (strategy === 'fixed') {
-            return 1000;
+        config.authManager.isAuthenticated().then(isAuth => {
+            this._isAuthenticated = isAuth;
+        });
+        config.authManager.getCompanyId().then(companyId => {
+            this.companyId = companyId;
+        });
+        this.socket = io(config.baseUrl, { autoConnect: false, transports: ["websocket"], });
+        if (!this.socket.connected) {
+            this.config.authManager.accessToken().then(token => {
+                console.log('Initializing socket connection with token...');
+                this.socket.auth = { token: token };
+                this.socket.connect();
+            });
         }
-        else if (strategy === 'exponential') {
-            return Math.pow(2, attempt) * 100;
+        this.socket.on('connect', () => {
+            this._isAuthenticated = true;
+            console.log(`Socket connected with ID: ${this.socket?.id}`);
+        });
+        this.socket.on('disconnect', (reason) => {
+            console.log(`Socket disconnected: ${reason}`);
+        });
+        this.socket.on('connect_error', (err) => {
+            console.error(`Socket connection error: ${err.message}`);
+        });
+        this.config.authManager.onTokenRefreshed((newAccessToken) => {
+            if (this.socket && newAccessToken) {
+                this._isAuthenticated = true;
+                console.log('Access token refreshed, updating socket auth...');
+                this.socket.auth = { token: newAccessToken };
+                this.socket.disconnect().connect();
+            }
+        });
+        config.authManager.onTokenRefreshFailed(() => {
+            this._isAuthenticated = false;
+            if (this.socket && this.socket.connected) {
+                this.socket.disconnect();
+            }
+        });
+    }
+    emit(eventName, data) {
+        if (!this.socket?.connected) {
+            console.error('Socket is not connected. Cannot emit event.');
+            return;
         }
-        throw new Error(`Invalid retry strategy: ${strategy}`);
+        this.socket.emit(eventName, data);
     }
-    _xhr(method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
-        const checkCancelled = () => {
-            if (cancelToken?.isCancelled()) {
-                return new StandardError(0, 'Request cancelled');
-            }
-            return null;
-        };
-        return this.config.authManager.accessToken().then(token => {
-            return new Promise((resolve, reject) => {
-                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);
-                        }
-                        else {
-                            let msg = xhr.statusText;
-                            try {
-                                const parsed = JSON.parse(xhr.responseText);
-                                msg = parsed.message || msg;
-                            }
-                            catch {
-                                console.warn('Failed to parse error response:', xhr.responseText);
-                            }
-                            reject(new StandardError(xhr.status, msg));
-                        }
-                    }
-                };
-                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);
-                    }
-                    else {
-                        reject(new StandardError(0, 'Network Error'));
+    on(eventName, callback) {
+        this.socket?.on(eventName, callback);
+    }
+    off(eventName, callback) {
+        this.socket?.off(eventName, callback);
+    }
+    get(path, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('GET', path, null, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
+    }
+    post(path, data, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('POST', path, data, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
+    }
+    put(path, data, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('PUT', path, data, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
+    }
+    delete(path, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('DELETE', path, null, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
+    }
+    useLogin() {
+        const queryClient = this.getQueryClient();
+        return useMutation({
+            mutationFn: async ({ username, password, code, cancelToken }) => {
+                const resp = await this.post('/login', JSON.stringify({ username, password, code }), cancelToken, { 'Content-Type': 'application/json' });
+                if (!resp || !('access_token' in resp)) {
+                    if (resp.msg === "TOTP required") {
+                        return LoginResponse.NEEDS_TOTP;
                     }
-                };
-                if (this.config.timeout) {
-                    xhr.timeout = this.config.timeout;
-                    xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
+                    throw new StandardError(401, 'Invalid login response');
                 }
-                xhr.send(body);
-            });
-        });
-    }
-    _fetch(method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
-        const checkCancelled = () => {
-            try {
-                if (cancelToken?.isCancelled()) {
-                    return new StandardError(0, 'Request cancelled');
+                this._isAuthenticated = true;
+                this.socket.auth = { token: resp.access_token };
+                if (!this.socket.connected) {
+                    this.socket.connect();
                 }
+                await this.config.authManager.setTokens({ access_token: resp.access_token, refresh_token: resp.refresh_token });
+                return LoginResponse.SUCCESS;
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                this.config.authManager.clearCache();
+                throw new StandardError(401, err.message || 'Login failed');
             }
-            catch (error) {
-                throw new StandardError(0, `Error checking cancellation (${typeof cancelToken}): ${error}`);
+        });
+    }
+    useRequestCode() {
+        const queryClient = this.getQueryClient();
+        return useMutation({
+            mutationFn: async ({ username, email, cancelToken }) => {
+                const resp = await this.post('/code', JSON.stringify({ username, email }), cancelToken, { 'Content-Type': 'application/json' });
+                return resp;
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                throw new StandardError(err.status, err.message || 'Request code failed');
             }
-            return null;
-        };
-        return this.config.authManager.accessToken().then(token => {
-            const cancelErr = checkCancelled();
-            if (cancelErr)
-                return Promise.reject(cancelErr);
-            const url = this.config.baseUrl + path;
-            const requestHeaders = {
-                'Content-Type': 'application/json',
-                ...headers,
-            };
-            if (token) {
-                requestHeaders['Authorization'] = `Bearer ${token}`;
+        });
+    }
+    useUpdatePassword() {
+        const queryClient = this.getQueryClient();
+        return useMutation({
+            mutationFn: async ({ username, email, code, newPassword, cancelToken }) => {
+                await this.post(`/user/${username ?? email}/password`, JSON.stringify({ code, password: newPassword }), cancelToken, { 'Content-Type': 'application/json' });
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                throw new StandardError(err.status, err.message || 'Update password failed');
             }
-            const options = {
-                method,
-                headers: requestHeaders,
-                body: body ? JSON.stringify(body) : null,
-            };
-            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);
-                        });
+        });
+    }
+    useGoogleLogin() {
+        const queryClient = this.getQueryClient();
+        return useMutation({
+            mutationFn: async ({ token, cancelToken }) => {
+                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 required") {
+                        return LoginResponse.NEEDS_TOTP;
                     }
+                    throw new StandardError(401, 'Invalid Google login response');
                 }
-                return response.json();
-            });
+                this._isAuthenticated = true;
+                this.socket.auth = { token: resp.access_token };
+                if (!this.socket.connected) {
+                    this.socket.connect();
+                }
+                await this.config.authManager.setTokens({ access_token: resp.access_token, refresh_token: resp.refresh_token });
+                return LoginResponse.SUCCESS;
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                this.config.authManager.clearCache();
+                throw new StandardError(err.status, err.message || 'Google Login failed');
+            }
         });
     }
-    get(path, cancelToken, headers = {}) {
-        return this._xhr('GET', path, null, cancelToken, headers, true);
+    setTokens(tokens) {
+        return this.config.authManager.setTokens(tokens);
+    }
+    setCache(data) {
+        return this.config.authManager.setCache(data);
+    }
+    getCache(key) {
+        return this.config.authManager.getCache(key);
     }
-    post(path, data, cancelToken, headers = {}) {
-        return this._xhr('POST', path, data, cancelToken, headers, false);
+    setCompanyId(companyId) {
+        this.companyId = companyId;
+        return this.config.authManager.setCompanyId(companyId);
     }
-    put(path, data, cancelToken, headers = {}) {
-        return this._xhr('PUT', path, data, cancelToken, headers, true);
+    clearCache() {
+        return this.config.authManager.clearCache();
     }
-    delete(path, cancelToken, headers = {}) {
-        return this._xhr('DELETE', path, null, cancelToken, headers, false);
+    isAuthenticated() {
+        return this._isAuthenticated;
     }
-    login(data, cancelToken) {
-        return this._fetch('POST', '/login', data, cancelToken)
-            .then(tokens => {
-            if (!tokens || !tokens.access_token || !tokens.refresh_token) {
-                throw new StandardError(401, 'Invalid login response');
+    isAuthenticatedAsync() {
+        return this.config.authManager.isAuthenticated();
+    }
+    getQueryClient() {
+        return this.config.queryClient;
+    }
+    useLogout() {
+        const queryClient = this.getQueryClient();
+        return useMutation({
+            mutationFn: async (cancelToken) => {
+                await this.post('/logout', null, cancelToken);
+                await this.config.authManager.clearCache();
+                if (this.socket && this.socket.connected) {
+                    this.socket.disconnect();
+                }
+            },
+            onSettled: () => {
+                this._isAuthenticated = false;
+                this.clearCache();
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                this.clearCache();
+                console.error('Logout failed:', err);
+                throw new StandardError(500, 'Logout failed');
             }
-            return this.config.authManager.setTokens(tokens).then(() => true);
+        });
+    }
+    fetchJobs(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/jobs`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid jobs response');
+            }
+            return response;
         })
             .catch(err => {
-            console.error('Login failed:', err);
-            throw new StandardError(401, 'Login failed');
+            console.error('Failed to fetch jobs:', err);
+            throw new StandardError(500, `Failed to fetch jobs: ${err.message ?? err}`);
         });
     }
-    logout(cancelToken) {
-        return this._fetch('POST', '/logout', null, cancelToken)
-            .then(() => this.config.authManager.clearTokens())
+    fetchChats(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/chats`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid chats response');
+            }
+            return response;
+        })
             .catch(err => {
-            console.error('Logout failed:', err);
-            throw new StandardError(500, 'Logout failed');
+            console.error('Failed to fetch chats:', err);
+            throw new StandardError(500, 'Failed to fetch chats');
         });
     }
-    fetchJobs(companyGuid, amt = 50, knownIds = [], unknownIds = [], keyword = '', offset = 0, cancelToken, headers = {}) {
-        const body = {
-            amt,
-            known_ids: knownIds,
-            unknown_ids: unknownIds,
-            query: keyword,
-        };
-        if (!companyGuid) {
-            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+    fetchMessages(chatId, body = {}, cancelToken, headers = {}) {
+        if (!chatId || chatId.trim() === '') {
+            throw new StandardError(400, 'Chat ID is required');
         }
-        return this._fetch('POST', `/company/${companyGuid}/jobs?amt=${amt}&offset=${offset}`, body, cancelToken, headers)
+        return this._fetch('POST', `/chat/${chatId}/messages`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
             .then(response => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid jobs response');
+                throw new StandardError(400, 'Invalid messages response');
             }
             return response;
         })
             .catch(err => {
-            console.error('Failed to fetch jobs:', err);
-            throw new StandardError(500, 'Failed to fetch jobs');
+            console.error('Failed to fetch messages:', err);
+            throw new StandardError(500, 'Failed to fetch messages');
         });
     }
-    fetchEvents(companyGuid, amt = 50, knownIds = [], unknownIds = [], keyword = '', offset = 0, unbilled = true, billed = true, paid = true, jobId = null, cancelToken, headers = {}) {
-        const body = {
-            amt,
-            known_ids: knownIds,
-            unknown_ids: unknownIds,
-            query: keyword,
-            job_id: jobId,
-        };
-        if (!companyGuid) {
-            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+    async fetchEvents(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
         }
-        return this._fetch('POST', `/company/${companyGuid}/events?amt=${amt}&offset=${offset}&unbilled=${unbilled}&billed=${billed}&paid=${paid}`, body, cancelToken, headers)
+        return this._fetch('POST', `/company/${this.companyId}/events`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
             .then(response => {
             if (!response || !Array.isArray(response)) {
                 throw new StandardError(400, 'Invalid events response');
@@ -247,17 +287,33 @@ export class AvroQueryClient {
             throw new StandardError(500, 'Failed to fetch events');
         });
     }
-    fetchBills(companyGuid, amt = 50, known_ids = [], unknown_ids = [], keyword = '', offset = 0, cancelToken, headers = {}) {
-        const body = {
-            amt,
-            known_ids,
-            unknown_ids,
-            query: keyword,
-        };
-        if (!companyGuid) {
-            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+    fetchMonths(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
         }
-        return this._fetch('POST', `/company/${companyGuid}/bills?amt=${amt}&offset=${offset}`, body, cancelToken, headers)
+        return this._fetch('POST', `/company/${this.companyId}/months`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid months response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch months:', err);
+            throw new StandardError(500, 'Failed to fetch months');
+        });
+    }
+    fetchBills(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/bills`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
             .then(response => {
             if (!response || !Array.isArray(response)) {
                 throw new StandardError(400, 'Invalid bills response');
@@ -269,4 +325,88 @@ export class AvroQueryClient {
             throw new StandardError(500, 'Failed to fetch bills');
         });
     }
+    fetchRoutes(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/routes`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid routes response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch routes:', err);
+            throw new StandardError(500, 'Failed to fetch routes');
+        });
+    }
+    fetchTeams(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/teams`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid teams response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch teams:', err);
+            throw new StandardError(500, 'Failed to fetch teams');
+        });
+    }
+    fetchSkills(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/skills`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid skills response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch skills:', err);
+            throw new StandardError(500, 'Failed to fetch skills');
+        });
+    }
+    fetchSessions(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/sessions`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid sessions response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch sessions:', err);
+            throw new StandardError(500, 'Failed to fetch sessions');
+        });
+    }
+    sendEmail(emailId, formData, progressUpdateCallback) {
+        try {
+            return this.post(`/email/${emailId}`, formData, undefined, {}, progressUpdateCallback);
+        }
+        catch (error) {
+            throw new StandardError(500, `Failed to send email: ${error}`);
+        }
+    }
 }

package/dist/client/core/fetch.d.ts

@@ -0,0 +1 @@
+export {};