@go-avro/avro-js 0.0.2-beta.1 → 0.0.2-beta.11

package/dist/auth/AuthManager.d.ts

@@ -6,8 +6,10 @@ export declare class AuthManager {
         baseUrl: string;
         storage: TokenStorage | TokenStorage[];
     });
+    isAuthenticated(): Promise<boolean>;
     fetchNewTokens(): Promise<Tokens>;
     accessToken(): Promise<string | undefined>;
     refreshTokens(): Promise<Tokens | null>;
-    clearToken(): Promise<void>;
+    setTokens(tokens: Tokens): Promise<void>;
+    clearTokens(): Promise<void>;
 }

package/dist/auth/AuthManager.js

@@ -11,32 +11,70 @@ export class AuthManager {
         });
         this.baseUrl = baseUrl;
     }
-    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);
+    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) {
+                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;
+                        }
+                    }
                 }
-            });
-            reject(new Error('No valid refresh token found'));
-        });
-        if (!refreshToken) {
-            throw new Error('No refresh token available');
+                catch (error) {
+                    console.error('Error validating access token:', error);
+                }
+            }
         }
-        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');
+        return false;
+    }
+    async fetchNewTokens() {
+        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;
+                }
+            }
+            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) {
@@ -61,7 +99,10 @@ export class AuthManager {
             return null;
         }
     }
-    async clearToken() {
+    async setTokens(tokens) {
+        await Promise.all(this.storages.map(s => s.set(tokens)));
+    }
+    async clearTokens() {
         await Promise.all(this.storages.map(s => s.clear()));
     }
 }

package/dist/client/QueryClient.d.ts

@@ -12,8 +12,17 @@ export declare class AvroQueryClient {
     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>;
     delete<T>(path: string, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<T>;
+    login(data: {
+        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, known_ids?: string[], unknown_ids?: string[], keyword?: string, offset?: number, unbilled?: boolean, billed?: boolean, paid?: boolean, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchBills(companyGuid: string, amt?: number, known_ids?: string[], unknown_ids?: string[], keyword?: string, offset?: number, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
 }

package/dist/client/QueryClient.js

@@ -104,6 +104,71 @@ export class AvroQueryClient {
             });
         });
     }
+    _fetch(method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
+        const checkCancelled = () => {
+            try {
+                if (cancelToken?.isCancelled()) {
+                    return new StandardError(0, 'Request cancelled');
+                }
+            }
+            catch (error) {
+                console.error(`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();
+            });
+        });
+    }
     get(path, cancelToken, headers = {}) {
         return this._xhr('GET', path, null, cancelToken, headers, true);
     }
@@ -116,4 +181,91 @@ export class AvroQueryClient {
     delete(path, cancelToken, headers = {}) {
         return this._xhr('DELETE', path, null, cancelToken, headers, false);
     }
+    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');
+            }
+            return this.config.authManager.setTokens(tokens).then(() => true);
+        })
+            .catch(err => {
+            console.error('Login failed:', err);
+            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, known_ids = [], unknown_ids = [], keyword = '', offset = 0, unbilled = true, billed = true, paid = true, cancelToken, headers = {}) {
+        const body = {
+            amt,
+            known_ids,
+            unknown_ids,
+            query: keyword,
+        };
+        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');
+        });
+    }
+    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'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/bills?amt=${amt}&offset=${offset}`, 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');
+        });
+    }
 }

package/dist/types/api.d.ts

@@ -1,19 +1,506 @@
-export interface AvroUser {
+export interface PaymentMethod {
+    allow_redisplay: string;
+    autopay: boolean;
+    billing_details: {
+        email: string;
+        name: string;
+    };
+    created: number;
+    customer: string;
+    id: string;
+    type: "us_bank_account" | "card";
+    us_bank_account: {
+        account_holder_type: string;
+        account_type: string;
+        bank_name: string;
+        financial_connections_account: string;
+        fingerprint: string;
+        last4: string;
+        networks: {
+            preferred: string;
+            supported: string[];
+        };
+        routing_number: string;
+        status_details: object;
+    } | null;
+    card: {
+        brand: string;
+        checks: {
+            address_line1_check: string;
+            address_postal_code_check: string;
+            cvc_check: string;
+        };
+        country: string;
+        exp_month: number;
+        exp_year: number;
+        fingerprint: string;
+        funding: string;
+        last4: string;
+        networks: {
+            preferred: string;
+            supported: string[];
+        };
+        three_d_secure_usage: {
+            supported: boolean;
+        };
+        wallet: {
+            type: string;
+        } | null;
+    } | null;
+}
+export interface Avro {
+    id: string;
+    name: string;
+    time_created: number;
+    time_updated: number;
+    emails: Email[];
+    totp_email_id: string;
+    billing_email_id: string;
+    join_email_id: string;
+}
+export interface Friendship {
+}
+export interface MemberState {
+    id: string;
+    state: string;
+    friendship: Friendship | null;
+    last_message_read_at: number | null;
+}
+export interface LineItem {
+    id: string;
+    name: string;
+    description: string;
+    cost: number | null;
+    amount: number | null;
+    time_created: number;
+}
+export interface Reaction {
+    id: string;
+    message_id: string;
+    sender_id: string;
+    reaction: string;
+    time_created: number;
+    time_updated: number;
+}
+export interface Message {
+    id: string;
+    chat_id: string;
+    sender_id: string;
+    reply_to_id: string;
+    content: string;
+    reactions: Reaction[];
+    time_created: number;
+    time_updated: number;
+    time_sent: number;
+    message: string;
+}
+export interface Chat {
+    id: string;
+    name: string;
+    company_id: string;
+    time_created: number;
+    time_updated: number;
+    last_message: Message;
+    user_state: MemberState[];
+    messages: Message[];
+}
+export interface TeamLocation {
+    accuracy: number;
+    heading: number;
+    id: string;
+    latitude: number;
+    longitude: number;
+    time_collected: number;
+    time_created: number;
+    time_updated: number | null;
+}
+export interface Team {
+    autoconfigure: boolean;
+    company_id: string;
+    description: string;
+    end: number[];
+    end_time: number;
+    fixed_cost: number;
+    hourly_cost: number;
+    id: string;
+    items: string[];
+    km_cost: number;
+    max_distance: number;
+    max_jobs: number;
+    max_travel_time: number;
+    color: string;
+    name: string;
+    profile: string;
+    routes: string[];
+    skills: string[];
+    speed_factor: number;
+    start_latitude: number;
+    start_longitude: number;
+    end_latitude: number;
+    end_longitude: number;
+    start_time: number;
+    users: string[];
+    current_location: TeamLocation;
+    start_address: string;
+    end_address: string;
+}
+export interface Subscription {
+    time_created: number;
+    time_updated: string;
+    user: User;
+    user_company_id: string;
+    job_id: string;
+    id: string;
+    notifications: number;
+}
+export interface Plan {
+    id: string;
+    name: string;
+    base_rate: number;
+    price_per_job: number;
+    description: string;
+    referral_codes: string[];
+    trial_period_days: number;
+    time_created: number;
+    time_updated: number;
+}
+export interface BillPayment {
+    id: string;
+    amount: number;
+    stripe_pi_id: string;
+    bill_user_id: string;
+    status: "created" | "processing" | "succeeded" | "failed" | "canceled" | "requires_action";
+    type: "us_bank_account" | "card";
+    action_required_at: number;
+    time_created: number;
+    time_updated: number | null;
+}
+export interface BillUser {
+    id: string;
+    user_id: string;
+    bill_id: string;
+    invoice_id: string;
+    payment_attempts: BillPayment[];
+    time_created: number;
+    time_updated: number | null;
+    amount: number;
+}
+export interface User {
+    id: string;
+    username: string;
+    name: string;
+    verified: boolean;
+    companies: UserCompanyAssociation[] | null;
+    email: string | null;
+    phone_number: string | null;
+    time_created: string | null;
+    time_updated: string | null;
+    can_send_emails: boolean | null;
+    payment_methods: PaymentMethod[];
+    autopay_payment_types: string[];
+    autopay: boolean | null;
+    chats: Chat[];
+    bills: BillUser[];
+}
+export interface Break {
+    id: string;
+    time_started: number;
+    time_ended: number;
+    company_billable: boolean;
+    client_billable: boolean;
+}
+export interface ServiceMonth {
+    id: string;
+    job_name: string;
+    job_id: string | null;
+    bill_id: string | null;
+    cost: number;
+    billed: boolean;
+    paid: boolean;
+    amount: number;
+    time_created: number;
+    time_updated: number | null;
+}
+export interface Session {
+    session_id: string;
+    user_id: string;
+    company_id: string;
+    time_started: number;
+    time_ended: number;
+    break_id: string;
+    is_paused: boolean;
+    team_id: string;
+    current_route_id: string;
+    breaks: Break[];
+}
+export interface Group {
+    id: string;
+    name: string;
+    is_active: boolean;
+    is_user_type: boolean;
+    users: string[];
+    permissions: string[];
+    company_id: string;
+    time_created: number;
+    time_updated: number;
+}
+export interface UserCompanyAssociation {
+    id: string;
+    user: User;
+    company: string;
+    permissions: string[];
+    effective_permissions: string[];
+    time_created: number | null;
+    time_updated: number | null;
+    notification_setting: number[];
+    share_email_company_wide: boolean;
+    notifications: number[];
+    groups: string[];
+}
+export interface Email {
+    id: string;
+    company_id: string;
+    name: string;
+    mail_server: string;
+    mail_port: number;
+    mail_username: string;
+    mail_password: string | null;
+    mail_default_sender: string;
+    mail_use_tls: boolean;
+    mail_use_ssl: boolean;
+    mail_api_key: string;
+    is_company_wide: boolean;
+    users: User[];
+    type: "OUTLOOK" | "SMTP" | "GMAIL";
+    access_token?: string;
+    access_token_expiry?: number;
+    refresh_token?: string;
+    refresh_token_expiry?: number;
+}
+export interface Label {
+    name: string;
+    id: string;
+    company_id: string;
+    color: string;
+    jobs: string[];
+}
+export interface Bill {
+    id: string;
+    invoice_id: number;
+    intuit_id: string | null;
+    name: string;
+    amount: number;
+    billed_by: string;
+    customer_email: string | null;
+    manual_emails: string[][];
+    users: BillUser[];
+    paid_at: number;
+    time_created: number;
+    time_updated: number;
+    events: string[];
+    intent_created_at: number;
+    intent_last_created_at: number;
+    payment: BillPayment | null;
+    line_items: LineItem[];
+    months: string[];
+    due_date: number;
+}
+export interface Skill {
     id: string;
     name: string;
+    company_id: string;
+    time_created: number;
+    time_updated: number;
+}
+export interface PlanPayment {
+    id: string;
+    amount: number;
+    stripe_pi_id: string;
+    company_id: string;
+    plan_id: string;
+    status: "created" | "processing" | "succeeded" | "failed" | "canceled";
+    time_created: number;
+    time_updated: number;
+}
+export interface Company {
+    events: _Event[];
+    months: ServiceMonth[];
+    id: string;
+    jobs: Job[];
+    name: string;
     email: string;
-    teams: AvroTeam[];
+    routes: Route[];
+    teams: Team[];
+    emails: Email[];
+    skills: Skill[];
+    time_created: string;
+    time_updated: string | null;
+    users: UserCompanyAssociation[];
+    use_client_side_customer_start_billing: boolean;
+    use_client_side_customer_stop_billing: boolean;
+    use_client_side_employee_start_billing: boolean;
+    use_client_side_employee_stop_billing: boolean;
+    logo_url: string;
+    delay_scalar: number;
+    incomplete_payments: PlanPayment[];
+    overdue_threshold: number;
+    stripe_account_id: string;
+    is_restricted: false;
+    disabled_reason: string;
+    completed_onboarding: boolean;
+    restricted_soon: boolean;
+    service_email_id: string;
+    billing_email_id: string;
+    num_events: number;
+    num_jobs: number;
+    bills: Bill[];
+    enabled_payment_methods: string[];
+    sessions: Session[];
+    num_sessions: number;
+    labels: Label[];
+    groups: Group[];
+    indicator_lifetime: number;
+    available_plans: Plan[];
+    last_payment: number;
+    last_charged: number;
+    balance: number;
+    plan_id: string;
+    payment_methods: PaymentMethod[];
+    autopay_payment_id: string;
+    intuit_connected: boolean;
+}
+export interface RouteJob {
+    time_created: number;
+    route_id: string;
+    job_id: string;
+    id: string;
+    order: number;
+    estimated_arrival_time: number;
+    scheduled_arrival_time: number;
+    tasks: string[];
 }
-export interface AvroTeam {
+export interface Route {
+    company: string;
     id: string;
+    is_internal: boolean;
+    jobs: RouteJob[];
     name: string;
-    members: AvroUser[];
+    time_created: number;
+    time_updated: number | null;
+    teams: string[];
+    polyline: string;
+    is_optimized: boolean;
+    start_time: number;
+    end_time: number;
+    start_latitude: number;
+    start_longitude: number;
+    end_latitude: number;
+    end_longitude: number;
 }
-export interface AvroJob {
+export interface Job {
+    address: string;
+    company: string;
+    description: string;
     id: string;
-    location: {
-        lat: number;
-        lng: number;
-    };
-    status: 'active' | 'pending' | 'complete';
+    is_one_time: boolean;
+    autostart_radius: number;
+    latitude: number;
+    longitude: number;
+    name: string;
+    internal_notes: string;
+    external_notes: string;
+    priority: number;
+    tasks: Task[];
+    time_created: number;
+    time_updated: number | null;
+    routes: RouteJob[];
+    subscribers: Subscription[];
+    manual_emails: string[][];
+    last_completed_event: _Event | null;
+    last_event: _Event | null;
+    labels: string[];
+    owner: string;
+}
+export interface Task {
+    enforce_proof_amount: boolean;
+    events: _Event[];
+    frequency: number;
+    id: string;
+    job_id: string;
+    name: string;
+    internal_notes: string;
+    external_notes: string;
+    proof_amt: number;
+    images: string[];
+    time_created: number;
+    time_updated: number | null;
+    status: "PENDING_CUSTOMER" | "PENDING_COMPANY" | "ACTIVE" | "ARCHIVED" | "DRAFT";
+    created_by: UserCompanyAssociation | null;
+    overdueness: number | null;
+    overdue_time: number;
+    last_event: _Event | null;
+    delay: number;
+    skills: string[];
+    service: number;
+    bill_mode: "MONTH" | "SERVICE" | "NONE";
+    price: number;
+    services_remaining: number;
+    expire_on: number | null;
+    bill_day: number | null;
+    services_prepaid: number;
+    months_prepaid: number;
+    priority: boolean;
+}
+export interface TaskWrapper {
+    latestEvent: number;
+    task: Task;
+}
+export interface JobWrapper {
+    latestEvent: number;
+    routeIndex: number;
+    job: Job;
+    frequency: number;
+    isOverdue: boolean;
+}
+export interface taskStartInfo {
+    name: string;
+    start: number;
+}
+export interface taskEndInfo {
+    end: number;
+    internal_notes: string;
+    external_notes: string;
+}
+export interface AdditionalCharge {
+    id: string;
+    time_created: number;
+    time_updated: number | null;
+    name: string;
+    amount: number;
+}
+export interface _Event {
+    breaks: string[];
+    id: string;
+    name: string;
+    internal_notes: string;
+    external_notes: string;
+    proofs: string[];
+    tasks: string[];
+    time_created: number;
+    time_ended: number;
+    time_started: number;
+    time_updated: number | null;
+    job_id: string;
+    job_name: string;
+    job_address: string;
+    bill_id: string;
+    billed_amount: number;
+    additional_charges: AdditionalCharge[];
+    user_id: string;
+    team_id: string;
+    cost: number;
+    billed: boolean;
+    paid: boolean;
+    autostart: boolean;
+    job_labels: string[];
 }

package/package.json

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