@go-avro/avro-js 0.0.2-beta.5 → 0.0.2-beta.51

package/README.md

@@ -10,6 +10,7 @@ This SDK provides:
 - Typed API interfaces for Avro entities (users, jobs, teams, etc.)
 - Pluggable token storage (in-memory, localStorage, SecureStore, etc.)
 - XHR-based requests for compatibility with React Native WebViews and older environments
+- Mutation and Data Hooks for easy plug-in use in React and React Native projects.
 
 ## Installation
 

package/dist/auth/AuthManager.js

@@ -26,7 +26,23 @@ export class AuthManager {
                             'Authorization': `Bearer ${tokens.access_token}`,
                         },
                     });
-                    return response.ok;
+                    if (response.ok) {
+                        return true;
+                    }
+                    else {
+                        // Attempt token refresh if validation fails
+                        const newTokens = await this.refreshTokens();
+                        if (newTokens && newTokens.access_token) {
+                            const retryResponse = await fetch(`${this.baseUrl}/validate`, {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                    'Authorization': `Bearer ${newTokens.access_token}`,
+                                },
+                            });
+                            return retryResponse.ok;
+                        }
+                    }
                 }
                 catch (error) {
                     console.error('Error validating access token:', error);

package/dist/client/QueryClient.d.ts

@@ -1,5 +1,8 @@
+import { InfiniteData, UseInfiniteQueryResult, useMutation, UseQueryResult } from '@tanstack/react-query';
 import { AuthManager } from '../auth/AuthManager';
+import { _Event, ApiInfo, Bill, Company, Job, LineItem, Route, ServiceMonth, Session, User } from '../types/api';
 import { CancelToken, RetryStrategy } from '../types/client';
+import { StandardError } from '../types/error';
 export interface AvroQueryClientConfig {
     baseUrl: string;
     authManager: AuthManager;
@@ -7,12 +10,169 @@ export interface AvroQueryClientConfig {
     retryStrategy?: RetryStrategy;
     timeout?: number;
 }
+declare module '../client/QueryClient' {
+    interface AvroQueryClient {
+        _xhr<T>(method: string, path: string, body: any, cancelToken?: CancelToken, headers?: Record<string, string>, isIdempotent?: boolean, retryCount?: number): 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;
+        useGetRoot(): UseQueryResult<ApiInfo, StandardError>;
+        useGetJobs(companyGuid: string, body: {
+            amt?: number;
+            query?: string;
+        }, total: number, onProgress?: (fraction: number) => void, isMainLoad?: boolean): UseQueryResult<Job[], StandardError>;
+        useGetRoutes(companyGuid: string, body: {
+            amt?: number;
+            query?: string;
+        }, total: number, onProgress?: (fraction: number) => void): UseQueryResult<any[], StandardError>;
+        useGetEvents(companyGuid: string, body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            unbilled?: boolean;
+            billed?: boolean;
+            paid?: boolean;
+            jobId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<_Event[], unknown>, StandardError>;
+        useGetMonths(companyGuid: string, body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            unbilled?: boolean;
+            billed?: boolean;
+            paid?: boolean;
+            jobId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<ServiceMonth[], unknown>, StandardError>;
+        useGetBills(companyGuid: string, body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            paid?: boolean;
+        }): UseInfiniteQueryResult<InfiniteData<Bill[], unknown>, StandardError>;
+        useGetCompanies(options?: {}): UseQueryResult<{
+            name: string;
+            id: string;
+        }[], StandardError>;
+        useGetCompany(companyId: string): UseQueryResult<Company, StandardError>;
+        useGetJob(jobId: string): UseQueryResult<Job, StandardError>;
+        useGetEvent(eventId: string): UseQueryResult<_Event, StandardError>;
+        useGetUser(userId: string): UseQueryResult<User, StandardError>;
+        useGetSelf(): UseQueryResult<User, StandardError>;
+        useGetBill(billId: string): UseQueryResult<Bill, StandardError>;
+        useGetRoute(routeId: string): UseQueryResult<Route, StandardError>;
+        useGetUserSessions(): UseQueryResult<Session[], StandardError>;
+        useCreateEvent(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            companyId: string;
+            eventData: Partial<_Event>;
+        }>>;
+        useCreateUserSession(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            companyId: string;
+            sessionData: Partial<Session>;
+        }>>;
+        useCreateBill(): ReturnType<typeof useMutation<{
+            id: string;
+            invoice_id: number;
+        }, StandardError, {
+            companyId: string;
+            data: {
+                line_items: LineItem[];
+                due_date: number;
+                users: string[];
+                custom_emails: [string, string][];
+            };
+        }>>;
+        useCreateJob(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            companyId: string;
+            jobData: Partial<Job>;
+        }>>;
+        useUpdateEvent(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            eventId: string;
+            updates: Partial<_Event>;
+        }>>;
+        useUpdateUserSession(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            sessionId: string;
+            updates: Partial<Session>;
+        }>>;
+        useUpdateJob(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            jobId: string;
+            updates: Partial<Job>;
+        }>>;
+        useUpdateBill(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            billId: string;
+            updates: Partial<Bill>;
+        }>>;
+        useUpdateRoute(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            routeId: string;
+            updates: Partial<Route>;
+        }>>;
+        useUpdateEvents(): ReturnType<typeof useMutation<void, StandardError, {
+            companyId: string;
+            events: (_Event & {
+                page?: number;
+            })[];
+            action: "billed" | "paid";
+        }>>;
+        useUpdateMonths(): ReturnType<typeof useMutation<void, StandardError, {
+            companyId: string;
+            months: (ServiceMonth & {
+                page?: number;
+            })[];
+            action: "billed" | "paid";
+        }>>;
+        useDeleteJob(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            jobId: string;
+        }>>;
+        useUpdateCompany(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            companyId: string;
+            companyData: Partial<Company | {
+                logo: File | null;
+            }>;
+        }>>;
+        useDeleteEvent(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            eventId: string;
+        }>>;
+        useDeleteBill(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            billId: string;
+        }>>;
+        useDeleteRoute(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            routeId: string;
+        }>>;
+        useDeleteSelf(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, void>>;
+    }
+}
 export declare class AvroQueryClient {
-    private config;
+    protected config: Required<AvroQueryClientConfig>;
     constructor(config: AvroQueryClientConfig);
-    getDelay(strategy: RetryStrategy, attempt: number): number;
-    private _xhr;
-    private _fetch;
     get<T>(path: string, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<T>;
     post<T>(path: string, data: any, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<T>;
     put<T>(path: string, data: any, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<T>;
@@ -22,5 +182,55 @@ export declare class AvroQueryClient {
         password: string;
     }, cancelToken?: CancelToken): Promise<Boolean>;
     logout(cancelToken?: CancelToken): Promise<void>;
-    fetchJobs(companyGuid: string, amt?: number, knownIds?: string[], unknownIds?: string[], keyword?: string, offset?: number, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchJobs(companyGuid: string, body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchEvents(companyGuid: string, body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        unbilled?: boolean;
+        billed?: boolean;
+        paid?: boolean;
+        jobId?: string | null;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchMonths(companyGuid: string, body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        unbilled?: boolean;
+        billed?: boolean;
+        paid?: boolean;
+        jobId?: string | null;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchBills(companyGuid: string, body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        paid?: boolean;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchRoutes(companyGuid: string, body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    sendEmail(emailId: string, formData: FormData): Promise<void>;
+    createBill(companyGuid: string, data: {
+        line_items: LineItem[];
+        due_date: number;
+        users: string[];
+        custom_emails: [string, string][];
+    }, cancelToken?: CancelToken): Promise<any>;
 }

package/dist/client/QueryClient.js

@@ -9,161 +9,6 @@ export class AvroQueryClient {
             timeout: config.timeout ?? 0,
         };
     }
-    getDelay(strategy, attempt) {
-        if (typeof strategy === 'function') {
-            return strategy(attempt);
-        }
-        else if (strategy === 'fixed') {
-            return 1000;
-        }
-        else if (strategy === 'exponential') {
-            return Math.pow(2, attempt) * 100;
-        }
-        throw new Error(`Invalid retry strategy: ${strategy}`);
-    }
-    _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'));
-                    }
-                };
-                if (this.config.timeout) {
-                    xhr.timeout = this.config.timeout;
-                    xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
-                }
-                xhr.send(body);
-            });
-        });
-    }
-    _fetch(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 => {
-            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}`;
-            }
-            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);
-                        });
-                    }
-                }
-                return response.json();
-            });
-        });
-    }
     get(path, cancelToken, headers = {}) {
         return this._xhr('GET', path, null, cancelToken, headers, true);
     }
@@ -197,17 +42,11 @@ export class AvroQueryClient {
             throw new StandardError(500, 'Logout failed');
         });
     }
-    fetchJobs(companyGuid, amt = 50, knownIds = [], unknownIds = [], keyword = '', offset = 0, cancelToken, headers = {}) {
-        const body = {
-            amt,
-            known_ids: knownIds,
-            unknown_ids: unknownIds,
-            query: keyword,
-        };
-        if (!companyGuid) {
+    fetchJobs(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
             return Promise.reject(new StandardError(400, 'Company GUID is required'));
         }
-        return this._fetch('POST', `/company/${companyGuid}/jobs?amt=${amt}&offset=${offset}`, body, cancelToken, headers)
+        return this._fetch('POST', `/company/${companyGuid}/jobs`, body, cancelToken, headers)
             .then(response => {
             if (!response || !Array.isArray(response)) {
                 throw new StandardError(400, 'Invalid jobs response');
@@ -219,4 +58,97 @@ export class AvroQueryClient {
             throw new StandardError(500, 'Failed to fetch jobs');
         });
     }
+    fetchEvents(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/events`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid events response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch events:', err);
+            throw new StandardError(500, 'Failed to fetch events');
+        });
+    }
+    fetchMonths(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/months`, body, cancelToken, headers)
+            .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(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/bills`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid bills response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch bills:', err);
+            throw new StandardError(500, 'Failed to fetch bills');
+        });
+    }
+    fetchRoutes(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/routes`, body, cancelToken, headers)
+            .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');
+        });
+    }
+    sendEmail(emailId, formData) {
+        try {
+            return this._xhr('POST', `/email/${emailId}`, formData);
+        }
+        catch (error) {
+            throw new StandardError(500, `Failed to send email: ${error}`);
+        }
+    }
+    createBill(companyGuid, data, cancelToken) {
+        if (!companyGuid) {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        const body = {
+            events: data.line_items.filter(item => item.line_item_type === 'EVENT').map(item => item.id),
+            months: data.line_items.filter(item => item.line_item_type === 'SERVICE_MONTH').map(item => item.id),
+            line_items: data.line_items.filter(item => item.line_item_type === 'CUSTOM'),
+            manual_emails: data.custom_emails,
+            users: data.users,
+            due_date: data.due_date,
+        };
+        try {
+            return this._xhr('POST', `/company/${companyGuid}/bill`, JSON.stringify(body), cancelToken, {
+                'Content-Type': 'application/json',
+            });
+        }
+        catch (error) {
+            throw new StandardError(500, `Failed to create bill: ${error}`);
+        }
+    }
 }

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

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

package/dist/client/core/fetch.js

@@ -0,0 +1,67 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { StandardError } from '../../types/error';
+AvroQueryClient.prototype._fetch = function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
+    const checkCancelled = () => {
+        try {
+            if (cancelToken?.isCancelled()) {
+                return new StandardError(0, 'Request cancelled');
+            }
+        }
+        catch (error) {
+            throw new StandardError(0, `Error checking cancellation (${typeof cancelToken}): ${error}`);
+        }
+        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}`;
+        }
+        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);
+                    });
+                }
+            }
+            return response.json();
+        });
+    });
+};

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

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

package/dist/client/core/utils.js

@@ -0,0 +1,13 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.getDelay = function (strategy, attempt) {
+    if (typeof strategy === 'function') {
+        return strategy(attempt);
+    }
+    else if (strategy === 'fixed') {
+        return 1000;
+    }
+    else if (strategy === 'exponential') {
+        return Math.pow(2, attempt) * 100;
+    }
+    throw new Error(`Invalid retry strategy: ${strategy}`);
+};

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

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