@go-avro/avro-js 0.0.2-beta.13 → 0.0.2-beta.131

package/dist/client/core/fetch.js

@@ -0,0 +1,62 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { StandardError } from '../../types/error';
+AvroQueryClient.prototype._fetch = async function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
+    const checkCancelled = () => {
+        try {
+            if (cancelToken?.isCancelled()) {
+                throw new StandardError(0, 'Request cancelled');
+            }
+        }
+        catch (error) {
+            throw new StandardError(0, `Error checking cancellation: ${error.message}`);
+        }
+    };
+    try {
+        checkCancelled();
+        const token = await this.config.authManager.accessToken();
+        checkCancelled();
+        const url = this.config.baseUrl + path;
+        const requestHeaders = {
+            Authorization: `Bearer ${token}`,
+            ...headers,
+        };
+        const options = {
+            method,
+            headers: requestHeaders,
+            body,
+        };
+        const response = await fetch(url, options);
+        if (response.ok) {
+            const text = await response.text();
+            if (!text) {
+                return undefined;
+            }
+            return JSON.parse(text);
+        }
+        if (response.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
+            await this.config.authManager.refreshTokens();
+            return this._fetch(method, path, body, cancelToken, headers, isIdempotent, 1);
+        }
+        if (retryCount < this.config.maxRetries) {
+            const delay = this.getDelay(this.config.retryStrategy, retryCount);
+            await this.sleep(delay);
+            return this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1);
+        }
+        let errorMessage = response.statusText;
+        try {
+            const parsedError = await response.json();
+            errorMessage = parsedError.message ?? parsedError.msg ?? errorMessage;
+        }
+        catch (e) {
+            console.error('Ignoring:', e);
+        }
+        throw new StandardError(response.status, errorMessage);
+    }
+    catch (error) {
+        if (error instanceof StandardError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new StandardError(0, `Request failed: ${message}`);
+    }
+};

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

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

package/dist/client/core/utils.js

@@ -0,0 +1,14 @@
+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}`);
+};
+AvroQueryClient.prototype.sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

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

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

package/dist/client/core/xhr.js

@@ -0,0 +1,84 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { StandardError } from '../../types/error';
+AvroQueryClient.prototype._xhr = async function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0, progressUpdateCallback) {
+    const checkCancelled = () => {
+        if (cancelToken?.isCancelled()) {
+            throw new StandardError(0, 'Request cancelled');
+        }
+    };
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+        try {
+            checkCancelled();
+            const token = await this.config.authManager.accessToken();
+            checkCancelled();
+            const result = await new Promise((resolve, reject) => {
+                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 = () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        try {
+                            const responseText = xhr.responseText;
+                            if (!responseText) {
+                                return resolve(undefined);
+                            }
+                            resolve(JSON.parse(responseText));
+                        }
+                        catch (e) {
+                            reject(new StandardError(0, `Failed to parse successful response: ${e.message}`));
+                        }
+                    }
+                    else {
+                        let msg = xhr.responseText || xhr.statusText;
+                        try {
+                            const parsed = JSON.parse(xhr.responseText);
+                            msg = parsed.message ?? parsed.msg ?? msg;
+                        }
+                        catch (e) {
+                            console.error('Ignoring:', e);
+                        }
+                        reject(new StandardError(xhr.status, msg));
+                    }
+                };
+                xhr.onerror = () => reject(new StandardError(0, 'Network Error'));
+                if (this.config.timeout) {
+                    xhr.timeout = this.config.timeout;
+                    xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
+                }
+                if (progressUpdateCallback && xhr.upload) {
+                    xhr.upload.onprogress = (event) => {
+                        if (event.lengthComputable) {
+                            progressUpdateCallback(event.loaded, event.total);
+                        }
+                    };
+                }
+                xhr.send(body);
+            });
+            return result;
+        }
+        catch (error) {
+            if (!(error instanceof StandardError)) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new StandardError(0, `An unexpected error occurred: ${message}`);
+            }
+            if (error.status === 401 && this.config.authManager.refreshTokens && attempt === 0) {
+                try {
+                    await this.config.authManager.refreshTokens();
+                    continue;
+                }
+                catch (refreshError) {
+                    throw new StandardError(401, 'Unauthorized (refresh failed)');
+                }
+            }
+            if (attempt >= this.config.maxRetries) {
+                throw error;
+            }
+            const delay = this.getDelay(this.config.retryStrategy, attempt);
+            await this.sleep(delay);
+        }
+    }
+    throw new StandardError(0, 'Request failed after maximum retries.');
+};

package/dist/client/hooks/analytics.d.ts

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

package/dist/client/hooks/analytics.js

@@ -0,0 +1,26 @@
+import { useQuery } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetAnalytics = function () {
+    return useQuery({
+        queryKey: ['analytics'],
+        queryFn: () => this.post('/avro/analytics', null),
+        enabled: true,
+    });
+};
+AvroQueryClient.prototype.useFinanceAnalytics = function ({ periods, cumulative }) {
+    return useQuery({
+        queryKey: ['analytics', 'finance', this.companyId, periods, cumulative],
+        queryFn: () => this.post(`/company/${this.companyId}/analytics/finance`, JSON.stringify({ periods, cumulative }), undefined, {
+            'Content-Type': 'application/json',
+        }),
+    });
+};
+AvroQueryClient.prototype.useEventAnalytics = function ({ periods }) {
+    return useQuery({
+        queryKey: ['analytics', 'events', this.companyId, periods],
+        queryFn: () => this.post(`/company/${this.companyId}/analytics/events`, JSON.stringify({ periods }), undefined, {
+            'Content-Type': 'application/json',
+        }),
+        enabled: Boolean(this.companyId),
+    });
+};

package/dist/client/hooks/avro.d.ts

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

package/dist/client/hooks/avro.js

@@ -0,0 +1,9 @@
+import { useQuery } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetAvro = function () {
+    return useQuery({
+        queryKey: ['avro'],
+        queryFn: () => this.get('/avro'),
+        enabled: true,
+    });
+};

package/dist/client/hooks/bills.d.ts

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

package/dist/client/hooks/bills.js

@@ -0,0 +1,165 @@
+import { useInfiniteQuery, useQuery, useMutation } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useGetBills = function (body) {
+    const queryClient = this.getQueryClient();
+    const result = useInfiniteQuery({
+        queryKey: [
+            'bills',
+            this.companyId,
+            body.query ?? "",
+            body.known_ids ?? [],
+            body.unknown_ids ?? [],
+            body.paid ?? false,
+        ],
+        initialPageParam: 0,
+        getNextPageParam: (lastPage, allPages) => {
+            if (lastPage.length < (body.amt ?? 50))
+                return undefined;
+            return allPages.flat().length; // next offset
+        },
+        queryFn: ({ pageParam = 0 }) => this.fetchBills({ ...body, offset: pageParam }),
+    });
+    if (result.data) {
+        result.data.pages.forEach((data_page) => {
+            data_page.forEach((bill) => {
+                queryClient.setQueryData(['bill', bill.id], bill);
+            });
+        });
+    }
+    return result;
+};
+AvroQueryClient.prototype.useGetBill = function (billId) {
+    return useQuery({
+        queryKey: ['bill', billId],
+        queryFn: () => this.get(`/bill/${billId}`),
+        enabled: Boolean(billId),
+    });
+};
+AvroQueryClient.prototype.useCreateBill = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ data }) => {
+            const body = {
+                events: data.events ?? [],
+                months: data.months ?? [],
+                line_items: data.line_items ?? [],
+                manual_emails: data.manual_emails,
+                users: data.users,
+                due_date: data.due_date,
+            };
+            return this.post(`/company/${this.companyId}/bill`, JSON.stringify(body), undefined, {
+                'Content-Type': 'application/json',
+            });
+        },
+        onMutate: async () => {
+            await queryClient.cancelQueries({ queryKey: ['bills', this.companyId] });
+            const previousBills = queryClient.getQueryData(['bills', this.companyId]);
+            // TODO: Create a fake bill object for optimistic update and update events and months accordingly
+            return { previousBills };
+        },
+        onError: (_err, _variables, context) => {
+            if (context?.previousBills) {
+                queryClient.setQueryData(['bills'], context.previousBills);
+            }
+        },
+        onSettled: (_data, _error) => {
+            queryClient.invalidateQueries({ queryKey: ['bills', this.companyId] });
+            queryClient.invalidateQueries({ queryKey: ['events', this.companyId] });
+            queryClient.invalidateQueries({ queryKey: ['months', this.companyId] });
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateBill = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: ({ billId, updates }) => {
+            return this.put(`/bill/${billId}`, JSON.stringify(updates), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ billId, updates }) => {
+            await queryClient.cancelQueries({ queryKey: ['bills'] });
+            await queryClient.cancelQueries({ queryKey: ['bill', billId] });
+            const previousBills = queryClient.getQueryData(['bills']);
+            const previousBill = queryClient.getQueryData(['bill', billId]);
+            queryClient.setQueryData(['bill', billId], (oldData) => oldData ? { ...oldData, ...updates } : undefined);
+            queryClient.setQueriesData({ queryKey: ['bills'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    return {
+                        ...oldData,
+                        pages: oldData.pages.map((page) => page.map((bill) => bill.id === billId ? { ...bill, ...updates } : bill)),
+                    };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((bill) => bill.id === billId ? { ...bill, ...updates } : bill);
+                }
+                return oldData;
+            });
+            return { previousBills, previousBill };
+        },
+        onError: (err, variables, context) => {
+            const { billId } = variables;
+            if (context?.previousBills) {
+                queryClient.setQueryData(['bills'], context.previousBills);
+            }
+            if (context?.previousBill) {
+                queryClient.setQueryData(['bill', billId], context.previousBill);
+            }
+        },
+        onSettled: (data, error, variables) => {
+            const { billId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['bills'] });
+            queryClient.invalidateQueries({ queryKey: ['bill', billId] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteBill = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ billId }) => {
+            return this.delete(`/bill/${billId}`);
+        },
+        onMutate: async ({ billId }) => {
+            await queryClient.cancelQueries({ queryKey: ['bills'] });
+            const previousBills = queryClient.getQueryData(['bills']);
+            // TODO: Create a fake bill object for optimistic update and update events and months accordingly
+            return { previousBills };
+        },
+        onError: (_err, _variables, context) => {
+            if (context?.previousBills) {
+                queryClient.setQueryData(['bills'], context.previousBills);
+            }
+        },
+        onSettled: (_data, _error) => {
+            queryClient.invalidateQueries({ queryKey: ['bills'] });
+            queryClient.invalidateQueries({ queryKey: ['events'] });
+            queryClient.invalidateQueries({ queryKey: ['months'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useSyncBillToIntuit = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ billId }) => {
+            return this.post(`/company/${this.companyId}/bill/${billId}/intuit/sync`, null);
+        },
+        onMutate: async ({ billId }) => {
+            await queryClient.cancelQueries({ queryKey: ['bill', billId] });
+            const previousBill = queryClient.getQueryData(['bill', billId]);
+            return { previousBill };
+        },
+        onError: (_err, variables, context) => {
+            const { billId } = variables;
+            if (context?.previousBill) {
+                queryClient.setQueryData(['bill', billId], context.previousBill);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { billId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['bill', billId] });
+        },
+    });
+};

package/dist/client/hooks/chats.d.ts

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

package/dist/client/hooks/chats.js

@@ -0,0 +1,37 @@
+import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetChats = function (body) {
+    const queryClient = this.getQueryClient();
+    const result = useInfiniteQuery({
+        queryKey: [
+            'chats',
+            this.companyId,
+            body.amt ?? 50,
+            body.known_ids ?? [],
+            body.unknown_ids ?? [],
+            body.query ?? '',
+        ],
+        initialPageParam: 0,
+        getNextPageParam: (lastPage, allPages) => {
+            if (lastPage.length < (body.amt ?? 50))
+                return undefined;
+            return allPages.flat().length; // next offset
+        },
+        queryFn: ({ pageParam = 0 }) => this.fetchChats({ ...body, offset: pageParam }),
+    });
+    if (result.data) {
+        result.data.pages.forEach((data_page) => {
+            data_page.forEach((chat) => {
+                queryClient.setQueryData(['chat', chat.id], chat);
+            });
+        });
+    }
+    return result;
+};
+AvroQueryClient.prototype.useGetChat = function (chatId) {
+    return useQuery({
+        queryKey: ['chat', chatId],
+        queryFn: () => this.get(`/chat/${chatId}`),
+        enabled: Boolean(chatId),
+    });
+};

package/dist/client/hooks/companies.d.ts

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

package/dist/client/hooks/companies.js

@@ -0,0 +1,137 @@
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useGetCompanies = function (options = {}) {
+    return useQuery({
+        queryKey: ['/company/list'],
+        queryFn: () => this.get('/company/list'),
+        ...options,
+    });
+};
+AvroQueryClient.prototype.useGetCompany = function (companyId) {
+    return useQuery({
+        queryKey: ['company', companyId],
+        queryFn: () => this.get(`/company/${companyId}`),
+        enabled: Boolean(companyId),
+    });
+};
+AvroQueryClient.prototype.useGetCurrentCompany = function () {
+    return useQuery({
+        queryKey: ['company', 'current'],
+        queryFn: async () => {
+            if (!this.companyId) {
+                const companyList = await this.get(`/company/list`);
+                if (companyList.length > 0) {
+                    this.companyId = companyList[0].id;
+                }
+                else {
+                    throw new Error("No company ID set and no companies available");
+                }
+            }
+            this.company = await this.get(`/company/${this.companyId}`);
+            return this.company;
+        },
+    });
+};
+AvroQueryClient.prototype.useCreateCompany = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ companyData }) => {
+            return this.post(`/company`, JSON.stringify(companyData), undefined, { "Content-Type": "application/json" });
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['/company/list'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateCompany = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ companyId, companyData, }) => {
+            return this.put(`/company/${companyId}`, JSON.stringify(companyData), undefined, { "Content-Type": "application/json" });
+        },
+        onMutate: async ({ companyId, companyData }) => {
+            await queryClient.cancelQueries({ queryKey: ['company', companyId] });
+            await queryClient.cancelQueries({ queryKey: ['/company/list'] });
+            const previousCompany = queryClient.getQueryData(['company', companyId]);
+            const previousCompanyList = queryClient.getQueryData(['/company/list']);
+            queryClient.setQueryData(['company', companyId], (oldData) => oldData ? { ...oldData, ...companyData } : undefined);
+            queryClient.setQueryData(['/company/list'], (oldList) => {
+                if (!oldList)
+                    return oldList;
+                return oldList.map((company) => company.id === companyId ? { ...company, ...companyData } : company);
+            });
+            return { previousCompany, previousCompanyList };
+        },
+        onError: (_err, variables, context) => {
+            const { companyId } = variables;
+            if (context?.previousCompany) {
+                queryClient.setQueryData(['company', companyId], context.previousCompany);
+            }
+            if (context?.previousCompanyList) {
+                queryClient.setQueryData(['/company/list'], context.previousCompanyList);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { companyId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['company', companyId] });
+            queryClient.invalidateQueries({ queryKey: ['/company/list'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useRemoveUserCompany = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ userId }) => {
+            return this.delete(`/company/${this.companyId}/user/${userId}`);
+        },
+        onMutate: async ({ userId }) => {
+            await queryClient.cancelQueries({ queryKey: ['company', this.companyId] });
+            const previousCompany = queryClient.getQueryData(['company', this.companyId]);
+            queryClient.setQueryData(['company', this.companyId], (oldData) => {
+                if (!oldData)
+                    return oldData;
+                return {
+                    ...oldData,
+                    users: oldData.users.filter((user) => user.id !== userId),
+                };
+            });
+            return { previousCompany };
+        },
+        onError: (err, variables, context) => {
+            if (context?.previousCompany) {
+                queryClient.setQueryData(['company', this.companyId], context.previousCompany);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            queryClient.invalidateQueries({ queryKey: ['company', this.companyId] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteCompany = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ companyId }) => {
+            return this.delete(`/company/${companyId}`);
+        },
+        onMutate: async ({ companyId }) => {
+            await queryClient.cancelQueries({ queryKey: ['/company/list'] });
+            await queryClient.cancelQueries({ queryKey: ['company', companyId] });
+            const previousCompanyList = queryClient.getQueryData(['/company/list']);
+            queryClient.setQueryData(['/company/list'], (oldList) => {
+                if (!oldList)
+                    return oldList;
+                return oldList.filter((company) => company.id !== companyId);
+            });
+            return { previousCompanyList };
+        },
+        onError: (err, companyId, context) => {
+            if (context?.previousCompanyList) {
+                queryClient.setQueryData(['/company/list'], context.previousCompanyList);
+            }
+        },
+        onSettled: (_data, _error, companyId) => {
+            queryClient.invalidateQueries({ queryKey: ['/company/list'] });
+            queryClient.invalidateQueries({ queryKey: ['company', companyId] });
+        },
+    });
+};

package/dist/client/hooks/events.d.ts

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