@go-avro/avro-js 0.0.2-beta.2 → 0.0.2-beta.20

package/dist/auth/AuthManager.d.ts

@@ -6,7 +6,7 @@ export declare class AuthManager {
         baseUrl: string;
         storage: TokenStorage | TokenStorage[];
     });
-    hasTokens(): Promise<boolean>;
+    isAuthenticated(): Promise<boolean>;
     fetchNewTokens(): Promise<Tokens>;
     accessToken(): Promise<string | undefined>;
     refreshTokens(): Promise<Tokens | null>;

package/dist/auth/AuthManager.js

@@ -11,41 +11,70 @@ export class AuthManager {
         });
         this.baseUrl = baseUrl;
     }
-    async hasTokens() {
+    async isAuthenticated() {
+        if (!this.storages.length) {
+            throw new Error('No token storages initialized');
+        }
         for (const storage of this.storages) {
             const tokens = await storage.get();
             if (tokens && tokens.access_token) {
-                return true;
+                try {
+                    const response = await fetch(`${this.baseUrl}/validate`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Authorization': `Bearer ${tokens.access_token}`,
+                        },
+                    });
+                    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);
+                }
             }
         }
         return false;
     }
     async fetchNewTokens() {
-        const refreshToken = await new Promise((resolve, reject) => {
-            this.storages.map(async (storage) => {
-                const tokens = await storage.get();
-                if (tokens) {
-                    resolve(tokens.refresh_token);
+        for (const storage of this.storages) {
+            const tokens = await storage.get();
+            if (!tokens || !tokens.refresh_token)
+                continue;
+            try {
+                const response = await fetch(`${this.baseUrl}/refresh`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Accept': 'application/json',
+                        'Authorization': `Bearer ${tokens.refresh_token}`,
+                    },
+                });
+                if (response.ok) {
+                    const newTokens = await response.json();
+                    return newTokens;
                 }
-            });
-            reject(new Error('No valid refresh token found'));
-        });
-        if (!refreshToken) {
-            throw new Error('No refresh token available');
-        }
-        const response = await fetch(`${this.baseUrl}/refresh`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Accept': 'application/json',
-                'Authorization': `Bearer ${refreshToken}`,
-            },
-        });
-        if (!response.ok) {
-            throw new Error('Failed to refresh tokens');
+            }
+            catch (error) {
+                storage.clear();
+            }
         }
-        const tokens = await response.json();
-        return tokens;
+        throw new Error('Failed to refresh tokens from all storages');
     }
     async accessToken() {
         if (!this.storages.length) {

package/dist/client/QueryClient.d.ts

@@ -1,4 +1,5 @@
 import { AuthManager } from '../auth/AuthManager';
+import { LineItem } from '../types/api';
 import { CancelToken, RetryStrategy } from '../types/client';
 export interface AvroQueryClientConfig {
     baseUrl: string;
@@ -21,4 +22,16 @@ export declare class AvroQueryClient {
         username: string;
         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>;
+    fetchEvents(companyGuid: string, amt?: number, knownIds?: string[], unknownIds?: string[], keyword?: string, offset?: number, unbilled?: boolean, billed?: boolean, paid?: boolean, jobId?: string | null, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchMonths(companyGuid: string, amt?: number, knownIds?: string[], unknownIds?: string[], keyword?: string, offset?: number, unbilled?: boolean, billed?: boolean, paid?: boolean, jobId?: string | null, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchBills(companyGuid: string, amt?: number, knownIds?: string[], unknownIds?: string[], keyword?: string, offset?: number, paid?: boolean, 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][];
+    }): Promise<any>;
 }

package/dist/client/QueryClient.js

@@ -106,8 +106,13 @@ export class AvroQueryClient {
     }
     _fetch(method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
         const checkCancelled = () => {
-            if (cancelToken?.isCancelled()) {
-                return new StandardError(0, 'Request cancelled');
+            try {
+                if (cancelToken?.isCancelled()) {
+                    return new StandardError(0, 'Request cancelled');
+                }
+            }
+            catch (error) {
+                throw new StandardError(0, `Error checking cancellation (${typeof cancelToken}): ${error}`);
             }
             return null;
         };
@@ -176,7 +181,6 @@ export class AvroQueryClient {
     delete(path, cancelToken, headers = {}) {
         return this._xhr('DELETE', path, null, cancelToken, headers, false);
     }
-    // add login that uses fetch and sets the tokens in the auth manager
     login(data, cancelToken) {
         return this._fetch('POST', '/login', data, cancelToken)
             .then(tokens => {
@@ -190,4 +194,135 @@ export class AvroQueryClient {
             throw new StandardError(401, 'Login failed');
         });
     }
+    logout(cancelToken) {
+        return this._fetch('POST', '/logout', null, cancelToken)
+            .then(() => this.config.authManager.clearTokens())
+            .catch(err => {
+            console.error('Logout failed:', err);
+            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) {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/jobs?amt=${amt}&offset=${offset}`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid jobs response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch jobs:', err);
+            throw new StandardError(500, 'Failed to fetch jobs');
+        });
+    }
+    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'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/events?amt=${amt}&offset=${offset}&unbilled=${unbilled}&billed=${billed}&paid=${paid}`, 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, 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'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/months?amt=${amt}&offset=${offset}&unbilled=${unbilled}&billed=${billed}&paid=${paid}`, 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, amt = 50, knownIds = [], unknownIds = [], keyword = '', offset = 0, paid = true, 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'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/bills?amt=${amt}&offset=${offset}&paid=${paid}`, 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');
+        });
+    }
+    sendEmail(emailId, formData) {
+        try {
+            return this._xhr('POST', `/email/${emailId}`, formData);
+        }
+        catch (error) {
+            console.error('Failed to send email', error);
+            throw error;
+        }
+    }
+    createBill(companyGuid, data) {
+        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,
+        };
+        return this._fetch('POST', `/company/${companyGuid}/bills`, body)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid bills response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to create bill:', err);
+            throw new StandardError(500, 'Failed to create bill');
+        });
+    }
 }

package/dist/types/api.d.ts

@@ -68,6 +68,16 @@ export interface MemberState {
 }
 export interface LineItem {
     id: string;
+    line_item_type: "CUSTOM" | "ADDITIONAL_CHARGE" | "EVENT" | "SERVICE_MONTH";
+    name: string;
+    description: string;
+    cost: number | null;
+    amount: number | null;
+    time_created: number;
+}
+export interface CustomLineItem {
+    id: string;
+    line_item_type: "CUSTOM";
     name: string;
     description: string;
     cost: number | null;
@@ -211,13 +221,17 @@ export interface Break {
 }
 export interface ServiceMonth {
     id: string;
+    line_item_type: "SERVICE_MONTH";
     job_name: string;
     job_id: string | null;
+    job_address: string;
+    job_labels: string[];
     bill_id: string | null;
     cost: number;
     billed: boolean;
     paid: boolean;
     amount: number;
+    tasks: string[];
     time_created: number;
     time_updated: number | null;
 }
@@ -301,7 +315,7 @@ export interface Bill {
     intent_created_at: number;
     intent_last_created_at: number;
     payment: BillPayment | null;
-    line_items: LineItem[];
+    line_items: CustomLineItem[];
     months: string[];
     due_date: number;
 }
@@ -473,14 +487,17 @@ export interface taskEndInfo {
 }
 export interface AdditionalCharge {
     id: string;
+    line_item_type: "ADDITIONAL_CHARGE";
     time_created: number;
     time_updated: number | null;
     name: string;
+    description: string;
     amount: number;
 }
 export interface _Event {
     breaks: string[];
     id: string;
+    line_item_type: "EVENT";
     name: string;
     internal_notes: string;
     external_notes: string;

package/package.json

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