@go-avro/avro-js 0.0.2-beta.3 → 0.0.2-beta.31

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,11 +11,42 @@ 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;

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;
@@ -22,5 +23,48 @@ 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, 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>;
+    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

@@ -28,8 +28,8 @@ export class AvroQueryClient {
             }
             return null;
         };
-        return this.config.authManager.accessToken().then(token => {
-            return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject) => {
+            this.config.authManager.accessToken().then(token => {
                 const cancelErr = checkCancelled();
                 if (cancelErr)
                     return reject(cancelErr);
@@ -76,7 +76,7 @@ export class AvroQueryClient {
                             let msg = xhr.statusText;
                             try {
                                 const parsed = JSON.parse(xhr.responseText);
-                                msg = parsed.message || msg;
+                                msg = parsed.msg || msg;
                             }
                             catch {
                                 console.warn('Failed to parse error response:', xhr.responseText);
@@ -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;
         };
@@ -197,17 +202,11 @@ export class AvroQueryClient {
             throw new StandardError(500, 'Logout failed');
         });
     }
-    fetchJobs(companyGuid, amt = 50, knownIds = [], unknownIds = [], keyword = '', 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}`, 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 +218,81 @@ 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');
+        });
+    }
+    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/types/api.d.ts

@@ -68,12 +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 extends LineItem {
+    line_item_type: "CUSTOM";
+}
 export interface Reaction {
     id: string;
     message_id: string;
@@ -209,16 +213,16 @@ export interface Break {
     company_billable: boolean;
     client_billable: boolean;
 }
-export interface ServiceMonth {
-    id: string;
+export interface ServiceMonth extends LineItem {
+    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;
-    time_created: number;
+    tasks: string[];
     time_updated: number | null;
 }
 export interface Session {
@@ -294,6 +298,7 @@ export interface Bill {
     customer_email: string | null;
     manual_emails: string[][];
     users: BillUser[];
+    paid: boolean;
     paid_at: number;
     time_created: number;
     time_updated: number;
@@ -301,7 +306,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;
 }
@@ -471,22 +476,17 @@ export interface taskEndInfo {
     internal_notes: string;
     external_notes: string;
 }
-export interface AdditionalCharge {
-    id: string;
-    time_created: number;
+export interface AdditionalCharge extends LineItem {
+    line_item_type: "ADDITIONAL_CHARGE";
     time_updated: number | null;
-    name: string;
-    amount: number;
 }
-export interface _Event {
+export interface _Event extends LineItem {
     breaks: string[];
-    id: string;
-    name: string;
+    line_item_type: "EVENT";
     internal_notes: string;
     external_notes: string;
     proofs: string[];
     tasks: string[];
-    time_created: number;
     time_ended: number;
     time_started: number;
     time_updated: number | null;
@@ -498,7 +498,6 @@ export interface _Event {
     additional_charges: AdditionalCharge[];
     user_id: string;
     team_id: string;
-    cost: number;
     billed: boolean;
     paid: boolean;
     autostart: boolean;

package/package.json

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