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

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.d.ts

@@ -1,13 +1,23 @@
-import { TokenStorage, Tokens } from '../types/auth';
+import { Tokens } from '../types/auth';
+import { Cache, CacheData } from '../types/cache';
 export declare class AuthManager {
     private storages;
     private baseUrl;
+    private tokenRefreshedCallbacks;
+    private tokenRefreshFailedCallbacks;
     constructor({ baseUrl, storage, }: {
         baseUrl: string;
-        storage: TokenStorage | TokenStorage[];
+        storage: Cache | Cache[];
     });
+    isAuthenticated(): Promise<boolean>;
     fetchNewTokens(): Promise<Tokens>;
     accessToken(): Promise<string | undefined>;
+    onTokenRefreshed(callback: (accessToken: string) => void): void;
+    onTokenRefreshFailed(callback: () => void): void;
     refreshTokens(): Promise<Tokens | null>;
-    clearToken(): Promise<void>;
+    setTokens(tokens: Tokens): Promise<void>;
+    setCache(data: Partial<CacheData>): Promise<void>;
+    clearCache(): Promise<void>;
+    getCompanyId(): Promise<string | null>;
+    setCompanyId(companyId: string): Promise<void>;
 }

package/dist/auth/AuthManager.js

@@ -1,5 +1,8 @@
+import { StandardError } from '../types/error';
 export class AuthManager {
     constructor({ baseUrl, storage, }) {
+        this.tokenRefreshedCallbacks = [];
+        this.tokenRefreshFailedCallbacks = [];
         this.storages = Array.isArray(storage) ? storage : [storage];
         if (this.storages.length === 0) {
             throw new Error('At least one token storage must be provided');
@@ -11,57 +14,128 @@ 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 cache = await storage.get();
+            if (cache && typeof cache !== 'string' && cache.access_token) {
+                try {
+                    const response = await fetch(`${this.baseUrl}/validate`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Authorization': `Bearer ${cache.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 cache = await storage.get();
+            if (!cache || typeof cache === 'string' || !cache.refresh_token)
+                continue;
+            try {
+                const response = await fetch(`${this.baseUrl}/refresh`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Accept': 'application/json',
+                        'Authorization': `Bearer ${cache.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 StandardError(410, 'Failed to refresh tokens from all storages');
     }
     async accessToken() {
         if (!this.storages.length) {
             throw new Error('No token storages initialized');
         }
         for (const storage of this.storages) {
-            const token = await storage.get();
-            if (token)
-                return token.access_token;
+            const cache = await storage.get();
+            if (cache && typeof cache !== 'string' && cache.access_token)
+                return cache.access_token;
         }
         const newToken = await this.refreshTokens();
         return newToken?.access_token;
     }
+    onTokenRefreshed(callback) {
+        this.tokenRefreshedCallbacks.push(callback);
+    }
+    onTokenRefreshFailed(callback) {
+        this.tokenRefreshFailedCallbacks.push(callback);
+    }
     async refreshTokens() {
         try {
             const newToken = await this.fetchNewTokens();
             await Promise.all(this.storages.map(s => s.set(newToken)));
+            this.tokenRefreshedCallbacks.forEach(cb => {
+                if (newToken?.access_token)
+                    cb(newToken.access_token);
+            });
             return newToken;
         }
         catch (error) {
-            console.error('Failed to refresh tokens:', error);
+            this.tokenRefreshFailedCallbacks.forEach(cb => cb());
+            if (error?.status !== 410) {
+                console.error('Failed to refresh tokens:', error);
+            }
             return null;
         }
     }
-    async clearToken() {
+    async setTokens(tokens) {
+        await Promise.all(this.storages.map(s => s.set(tokens)));
+    }
+    async setCache(data) {
+        await Promise.all(this.storages.map(s => s.set(data)));
+    }
+    async clearCache() {
         await Promise.all(this.storages.map(s => s.clear()));
     }
+    async getCompanyId() {
+        if (!this.storages.length) {
+            return null;
+        }
+        for (const storage of this.storages) {
+            const companyId = await storage.get('companyId');
+            if (companyId && typeof companyId === 'string')
+                return companyId;
+        }
+        return null;
+    }
+    async setCompanyId(companyId) {
+        await Promise.all(this.storages.map(s => s.set({ companyId })));
+    }
 }

package/dist/auth/storage.d.ts

@@ -1,13 +1,13 @@
-import { Tokens, TokenStorage } from '../types/auth';
-export declare class MemoryStorage implements TokenStorage {
-    private tokens;
-    get(): Promise<Tokens | null>;
-    set(tokens: Tokens): Promise<void>;
+import { Cache, CacheData } from '../types/cache';
+export declare class MemoryStorage implements Cache {
+    private data;
+    get(key?: keyof CacheData): Promise<CacheData | string | null>;
+    set(data: Partial<CacheData>): Promise<void>;
     clear(): Promise<void>;
 }
-export declare class LocalStorage implements TokenStorage {
+export declare class LocalStorage implements Cache {
     private key;
-    get(): Promise<Tokens | null>;
-    set(tokens: Tokens): Promise<void>;
+    get(key?: string): Promise<CacheData | null>;
+    set(data: Partial<CacheData>): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/auth/storage.js

@@ -1,27 +1,29 @@
 export class MemoryStorage {
     constructor() {
-        this.tokens = null;
+        this.data = null;
     }
-    async get() {
-        return this.tokens ? this.tokens : null;
+    async get(key) {
+        return this.data ? key ? this.data[key] ?? null : this.data : null;
     }
-    async set(tokens) {
-        this.tokens = tokens;
+    async set(data) {
+        this.data = { ...this.data, ...data };
     }
     async clear() {
-        this.tokens = null;
+        this.data = null;
     }
 }
 export class LocalStorage {
     constructor() {
-        this.key = 'auth_tokens';
+        this.key = 'cache_data';
     }
-    async get() {
+    async get(key) {
         const item = localStorage.getItem(this.key);
         return item ? JSON.parse(item) : null;
     }
-    async set(tokens) {
-        localStorage.setItem(this.key, JSON.stringify(tokens));
+    async set(data) {
+        const current = await this.get() || {};
+        const updated = { ...current, ...data };
+        localStorage.setItem(this.key, JSON.stringify(updated));
     }
     async clear() {
         localStorage.removeItem(this.key);

package/dist/client/QueryClient.d.ts

@@ -1,5 +1,11 @@
+import { Socket } from 'socket.io-client';
+import { InfiniteData, UseInfiniteQueryResult, useMutation, UseQueryResult } from '@tanstack/react-query';
 import { AuthManager } from '../auth/AuthManager';
+import { _Event, ApiInfo, Avro, Bill, Break, Chat, Company, Job, LineItem, LoginResponse, Message, Plan, Route, ServiceMonth, Session, Team, User, UserCompanyAssociation } from '../types/api';
+import { Tokens } from '../types/auth';
 import { CancelToken, RetryStrategy } from '../types/client';
+import { StandardError } from '../types/error';
+import { CacheData } from '../types/cache';
 export interface AvroQueryClientConfig {
     baseUrl: string;
     authManager: AuthManager;
@@ -7,13 +13,372 @@ 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, progressUpdateCallback?: (loaded: number, total: number) => void): 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;
+        sleep(ms: number): Promise<void>;
+        useGetRoot(): UseQueryResult<ApiInfo, StandardError>;
+        useGetJobs(body: {
+            amt?: number;
+            query?: string;
+            routeId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<Job[], unknown>, StandardError>;
+        useGetRoutes(body: {
+            amt?: number;
+            query?: string;
+        }, total: number, onProgress?: (fraction: number) => void): UseQueryResult<Route[], StandardError>;
+        useGetTeams(body: {
+            amt?: number;
+            query?: string;
+        }, total: number, onProgress?: (fraction: number) => void): UseQueryResult<Team[], StandardError>;
+        useGetEvents(body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            unbilled?: boolean;
+            billed?: boolean;
+            paid?: boolean;
+            jobId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<_Event[], unknown>, StandardError>;
+        useGetSessions(body: {
+            amt?: number;
+            query?: string;
+        }): UseInfiniteQueryResult<InfiniteData<Session[], unknown>, StandardError>;
+        useGetChats(body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+        }): UseInfiniteQueryResult<InfiniteData<Chat[], unknown>, StandardError>;
+        useGetMessages(chatId: string, body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            unbilled?: boolean;
+            billed?: boolean;
+            paid?: boolean;
+            jobId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<Message[], unknown>, StandardError>;
+        useGetMonths(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(body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            paid?: boolean;
+        }): UseInfiniteQueryResult<InfiniteData<Bill[], unknown>, StandardError>;
+        useGetPlans(code: string): UseQueryResult<Plan[], StandardError>;
+        useGetCompanies(options?: {}): UseQueryResult<{
+            name: string;
+            id: string;
+        }[], StandardError>;
+        useGetAnalytics(): UseQueryResult<any, 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>;
+        useGetChat(chatId: string): UseQueryResult<Chat, StandardError>;
+        useGetUserSessions(): UseQueryResult<Session[], StandardError>;
+        useGetAvro(): UseQueryResult<Avro, StandardError>;
+        useSearchUsers(searchUsername: string): UseQueryResult<User[], StandardError>;
+        useCreateEvent(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            companyId: string;
+            eventData: Partial<_Event>;
+        }>>;
+        useCreateUserSession(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            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][];
+            };
+        }>>;
+        useCreateCompany(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            companyData: Partial<Company | {
+                logo: File | null;
+            }>;
+        }>>;
+        useCreateJob(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            companyId: string;
+            jobData: Partial<Job>;
+        }>>;
+        useCreateRoute(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            companyId: string;
+            routeData: Partial<Route>;
+        }>>;
+        useCreateSelf(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            username: string;
+            name: string;
+            email: string;
+            password: string;
+            phone_number: string;
+            code?: string;
+            invite_token?: string;
+        }>>;
+        useCreateSessionBreak(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            sessionId: string;
+            breakData: Partial<Break>;
+        }>>;
+        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, {
+            events: (_Event & {
+                page?: number;
+            })[];
+            action: "billed" | "paid";
+        }>>;
+        useUpdateTeam(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            teamId: string;
+            teamData: Partial<Team>;
+        }>>;
+        useUpdateMonths(): ReturnType<typeof useMutation<void, StandardError, {
+            months: (ServiceMonth & {
+                page?: number;
+            })[];
+            action: "billed" | "paid";
+        }>>;
+        useUpdateUserCompany(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            user_id: string;
+            data: Partial<UserCompanyAssociation>;
+        }>>;
+        useUpdateSessionBreak(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            breakId: string;
+            updates: Partial<Break>;
+        }>>;
+        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>>;
+        useDeleteCompany(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            companyId: string;
+        }>>;
+        useDeleteTeam(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            teamId: string;
+        }>>;
+    }
+}
 export declare class AvroQueryClient {
-    private config;
+    protected config: Required<AvroQueryClientConfig>;
+    readonly socket: Socket;
+    _isAuthenticated: boolean;
+    companyId: string | null;
     constructor(config: AvroQueryClientConfig);
-    getDelay(strategy: RetryStrategy, attempt: number): number;
-    private _xhr;
-    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>;
+    emit(eventName: string, data: unknown): void;
+    on<T>(eventName: string, callback: (data: T) => void): void;
+    off(eventName: string, callback?: Function): void;
+    get<T>(path: string, cancelToken?: CancelToken, headers?: Record<string, string>, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+    post<T>(path: string, data: any, cancelToken?: CancelToken, headers?: Record<string, string>, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+    put<T>(path: string, data: any, cancelToken?: CancelToken, headers?: Record<string, string>, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+    delete<T>(path: string, cancelToken?: CancelToken, headers?: Record<string, string>, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+    useLogin(): ReturnType<typeof useMutation<LoginResponse, StandardError, {
+        username: string;
+        password?: string;
+        code?: string;
+        cancelToken?: CancelToken;
+    }>>;
+    useRequestCode(): ReturnType<typeof useMutation<{
+        msg: string;
+    }, StandardError, {
+        username?: string;
+        email?: string;
+        cancelToken?: CancelToken;
+    }>>;
+    useUpdatePassword(): ReturnType<typeof useMutation<void, StandardError, {
+        username?: string;
+        email?: string;
+        code: string;
+        newPassword: string;
+        cancelToken?: CancelToken;
+    }>>;
+    useGoogleLogin(): ReturnType<typeof useMutation<LoginResponse, StandardError, {
+        token: string;
+        cancelToken?: CancelToken;
+    }>>;
+    setTokens(tokens: Tokens): Promise<void>;
+    setCache(data: Partial<CacheData>): Promise<void>;
+    setCompanyId(companyId: string): void;
+    clearCache(): Promise<void>;
+    isAuthenticated(): boolean;
+    isAuthenticatedAsync(): Promise<boolean>;
+    useLogout(): ReturnType<typeof useMutation<void, StandardError, CancelToken | undefined>>;
+    fetchJobs(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        route_id?: string;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchChats(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchMessages(chatId: string, body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchEvents(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(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(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        paid?: boolean;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchRoutes(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchTeams(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchSessions(body?: {
+        amt?: number;
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    sendEmail(emailId: string, formData: FormData, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<void>;
+    createBill(data: {
+        line_items: LineItem[];
+        due_date: number;
+        users: string[];
+        custom_emails: [string, string][];
+    }, cancelToken?: CancelToken): Promise<any>;
 }