@go-avro/avro-js 0.0.37 → 0.0.39

package/dist/client/core/fetch.js

@@ -1,11 +1,11 @@
-import { AvroQueryClient } from '../../client/QueryClient';
-import { StandardError } from '../../types/error';
-import { AuthState } from '../../types/auth';
+import { AvroQueryClient } from "../../client/QueryClient";
+import { StandardError } from "../../types/error";
+import { AuthState } from "../../types/auth";
 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');
+                throw new StandardError(0, "Request cancelled");
             }
         }
         catch (error) {
@@ -14,7 +14,9 @@ AvroQueryClient.prototype._fetch = async function (method, path, body, cancelTok
     };
     try {
         checkCancelled();
-        const token = this.getAuthState() === AuthState.AUTHENTICATED ? await this.config.authManager.accessToken() : undefined;
+        const token = this.getAuthState() === AuthState.AUTHENTICATED
+            ? await this.config.authManager.accessToken()
+            : undefined;
         checkCancelled();
         const url = this.config.baseUrl + path;
         const requestHeaders = {
@@ -28,9 +30,9 @@ AvroQueryClient.prototype._fetch = async function (method, path, body, cancelTok
         };
         const response = await fetch(url, options);
         if (response.ok) {
-            const contentType = response.headers.get('content-type') ?? '';
-            if (contentType.includes('application/pdf') ||
-                contentType.includes('application/octet-stream')) {
+            const contentType = response.headers.get("content-type") ?? "";
+            if (contentType.includes("application/pdf") ||
+                contentType.includes("application/octet-stream")) {
                 return response.blob();
             }
             const text = await response.text();
@@ -39,7 +41,10 @@ AvroQueryClient.prototype._fetch = async function (method, path, body, cancelTok
             }
             return JSON.parse(text);
         }
-        if (response.status === 401 && this.config.authManager.refreshTokens && retryCount === 0 && this.getAuthState() === AuthState.AUTHENTICATED) {
+        if (response.status === 401 &&
+            this.config.authManager.refreshTokens &&
+            retryCount === 0 &&
+            this.getAuthState() === AuthState.AUTHENTICATED) {
             await this.config.authManager.refreshTokens();
             return this._fetch(method, path, body, cancelToken, headers, isIdempotent, 1);
         }
@@ -54,7 +59,7 @@ AvroQueryClient.prototype._fetch = async function (method, path, body, cancelTok
             errorMessage = parsedError.message ?? parsedError.msg ?? errorMessage;
         }
         catch (e) {
-            console.error('Ignoring:', e);
+            console.error("Ignoring:", e);
         }
         throw new StandardError(response.status, errorMessage);
     }
@@ -63,7 +68,7 @@ AvroQueryClient.prototype._fetch = async function (method, path, body, cancelTok
             throw error;
         }
         const message = error instanceof Error ? error.message : String(error);
-        console.error('Fetch error:', message);
+        console.error("Fetch error:", message);
         throw new StandardError(0, `Request failed: ${message}`);
     }
 };

package/dist/client/core/utils.js

@@ -1,14 +1,14 @@
-import { AvroQueryClient } from '../../client/QueryClient';
+import { AvroQueryClient } from "../../client/QueryClient";
 AvroQueryClient.prototype.getDelay = function (strategy, attempt) {
-    if (typeof strategy === 'function') {
+    if (typeof strategy === "function") {
         return strategy(attempt);
     }
-    else if (strategy === 'fixed') {
+    else if (strategy === "fixed") {
         return 1000;
     }
-    else if (strategy === 'exponential') {
+    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));
+AvroQueryClient.prototype.sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

package/dist/client/core/xhr.js

@@ -1,30 +1,32 @@
-import { AvroQueryClient } from '../../client/QueryClient';
-import { StandardError } from '../../types/error';
-import { AuthState } from '../../types/auth';
+import { AvroQueryClient } from "../../client/QueryClient";
+import { StandardError } from "../../types/error";
+import { AuthState } from "../../types/auth";
 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');
+            throw new StandardError(0, "Request cancelled");
         }
     };
     for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
         try {
             checkCancelled();
-            const token = this.getAuthState() === AuthState.AUTHENTICATED ? await this.config.authManager.accessToken() : undefined;
+            const token = this.getAuthState() === AuthState.AUTHENTICATED
+                ? await this.config.authManager.accessToken()
+                : undefined;
             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}`);
+                    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 contentType = xhr.getResponseHeader('content-type') || '';
-                            if (contentType.includes('application/pdf') ||
-                                contentType.includes('application/octet-stream')) {
+                            const contentType = xhr.getResponseHeader("content-type") || "";
+                            if (contentType.includes("application/pdf") ||
+                                contentType.includes("application/octet-stream")) {
                                 resolve(new Blob([xhr.response], { type: contentType }));
                                 return;
                             }
@@ -45,15 +47,15 @@ AvroQueryClient.prototype._xhr = async function (method, path, body, cancelToken
                             msg = parsed.message ?? parsed.msg ?? msg;
                         }
                         catch (e) {
-                            console.error('Ignoring:', e);
+                            console.error("Ignoring:", e);
                         }
                         reject(new StandardError(xhr.status, msg));
                     }
                 };
-                xhr.onerror = () => reject(new StandardError(0, 'Network Error'));
+                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'));
+                    xhr.ontimeout = () => reject(new StandardError(0, "Request timed out"));
                 }
                 if (progressUpdateCallback && xhr.upload) {
                     xhr.upload.onprogress = (event) => {
@@ -63,34 +65,37 @@ AvroQueryClient.prototype._xhr = async function (method, path, body, cancelToken
                     };
                 }
                 // Set responseType to 'blob' if expecting binary
-                const contentType = headers['Content-Type'] || '';
-                if (contentType.includes('application/pdf') ||
-                    contentType.includes('application/octet-stream')) {
-                    xhr.responseType = 'blob';
+                const contentType = headers["Content-Type"] || "";
+                if (contentType.includes("application/pdf") ||
+                    contentType.includes("application/octet-stream")) {
+                    xhr.responseType = "blob";
                 }
                 xhr.send(body);
             });
             return result;
         }
         catch (error) {
-            console.error('xhr error:', error);
+            console.error("xhr error:", error);
             if (!(error instanceof StandardError)) {
                 const message = error instanceof Error ? error.message : String(error);
-                console.error('Non-StandardError caught:', message);
+                console.error("Non-StandardError caught:", message);
                 throw new StandardError(0, `An unexpected error occurred: ${message}`);
             }
-            if (error.status === 401 && this.config.authManager.refreshTokens && attempt === 0 && this.getAuthState() === AuthState.AUTHENTICATED) {
-                console.log('Attempting to refresh tokens due to 401 response');
+            if (error.status === 401 &&
+                this.config.authManager.refreshTokens &&
+                attempt === 0 &&
+                this.getAuthState() === AuthState.AUTHENTICATED) {
+                console.log("Attempting to refresh tokens due to 401 response");
                 try {
                     await this.config.authManager.refreshTokens();
                     continue;
                 }
                 catch (refreshError) {
-                    throw new StandardError(401, 'Unauthorized (refresh failed)');
+                    throw new StandardError(401, "Unauthorized (refresh failed)");
                 }
             }
             if (error.status === 401 || attempt >= this.config.maxRetries) {
-                console.error('Not retrying request, throwing error.');
+                console.error("Not retrying request, throwing error.");
                 throw error;
             }
             const delay = this.getDelay(this.config.retryStrategy, attempt);
@@ -98,5 +103,5 @@ AvroQueryClient.prototype._xhr = async function (method, path, body, cancelToken
             await this.sleep(delay);
         }
     }
-    throw new StandardError(0, 'Request failed after maximum retries.');
+    throw new StandardError(0, "Request failed after maximum retries.");
 };

package/dist/client/hooks/analytics.js

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

package/dist/client/hooks/avro.js

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

package/dist/client/hooks/bills.js

@@ -1,10 +1,10 @@
-import { useInfiniteQuery, useQuery, useMutation } from '@tanstack/react-query';
-import { AvroQueryClient } from '../../client/QueryClient';
+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',
+            "bills",
             this.companyId,
             body.query ?? "",
             body.known_ids ?? [],
@@ -22,7 +22,7 @@ AvroQueryClient.prototype.useGetBills = function (body) {
     if (result.data) {
         result.data.pages.forEach((data_page) => {
             data_page.forEach((bill) => {
-                queryClient.setQueryData(['bills', bill.id], bill);
+                queryClient.setQueryData(["bills", bill.id], bill);
             });
         });
     }
@@ -30,7 +30,7 @@ AvroQueryClient.prototype.useGetBills = function (body) {
 };
 AvroQueryClient.prototype.useGetBill = function (billId) {
     return useQuery({
-        queryKey: ['bills', billId],
+        queryKey: ["bills", billId],
         queryFn: () => this.get({ path: `/bill/${billId}` }),
         enabled: Boolean(billId),
     });
@@ -53,19 +53,29 @@ AvroQueryClient.prototype.useCreateBill = function () {
                 path: `/company/${this.companyId}/bill`,
                 data: JSON.stringify(body),
                 headers: {
-                    'Content-Type': 'application/json',
-                }
+                    "Content-Type": "application/json",
+                },
             });
         },
         onMutate: async () => {
-            await queryClient.cancelQueries({ queryKey: ['bills', this.companyId] });
-            const previousBills = queryClient.getQueryData(['bills', this.companyId]);
+            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 };
         },
+        onSuccess: async (result) => {
+            await this._syncEntity(queryClient, {
+                action: "create",
+                entityKey: "bills",
+                id: result.id,
+                fetchPath: `/bill/${result.id}`,
+            });
+        },
         onError: (_err, _variables, context) => {
             if (context?.previousBills) {
-                queryClient.setQueryData(['bills'], context.previousBills);
+                queryClient.setQueryData(["bills"], context.previousBills);
             }
         },
     });
@@ -73,22 +83,22 @@ AvroQueryClient.prototype.useCreateBill = function () {
 AvroQueryClient.prototype.useUpdateBill = function () {
     const queryClient = this.getQueryClient();
     return useMutation({
-        mutationFn: ({ billId, updates }) => {
+        mutationFn: ({ billId, updates, }) => {
             return this.put({
                 path: `/bill/${billId}`,
                 data: JSON.stringify(updates),
                 headers: {
                     "Content-Type": "application/json",
-                }
+                },
             });
         },
         onMutate: async ({ billId, updates }) => {
-            await queryClient.cancelQueries({ queryKey: ['bills'] });
-            await queryClient.cancelQueries({ queryKey: ['bills', billId] });
-            const previousBills = queryClient.getQueryData(['bills']);
-            const previousBill = queryClient.getQueryData(['bills', billId]);
-            queryClient.setQueryData(['bills', billId], (oldData) => oldData ? { ...oldData, ...updates } : undefined);
-            queryClient.setQueriesData({ queryKey: ['bills'] }, (oldData) => {
+            await queryClient.cancelQueries({ queryKey: ["bills"] });
+            await queryClient.cancelQueries({ queryKey: ["bills", billId] });
+            const previousBills = queryClient.getQueryData(["bills"]);
+            const previousBill = queryClient.getQueryData(["bills", billId]);
+            queryClient.setQueryData(["bills", billId], (oldData) => oldData ? { ...oldData, ...updates } : undefined);
+            queryClient.setQueriesData({ queryKey: ["bills"] }, (oldData) => {
                 if (!oldData)
                     return oldData;
                 if (oldData.pages) {
@@ -104,13 +114,21 @@ AvroQueryClient.prototype.useUpdateBill = function () {
             });
             return { previousBills, previousBill };
         },
+        onSuccess: async (_result, { billId }) => {
+            await this._syncEntity(queryClient, {
+                action: "update",
+                entityKey: "bills",
+                id: billId,
+                fetchPath: `/bill/${billId}`,
+            });
+        },
         onError: (err, variables, context) => {
             const { billId } = variables;
             if (context?.previousBills) {
-                queryClient.setQueryData(['bills'], context.previousBills);
+                queryClient.setQueryData(["bills"], context.previousBills);
             }
             if (context?.previousBill) {
-                queryClient.setQueryData(['bills', billId], context.previousBill);
+                queryClient.setQueryData(["bills", billId], context.previousBill);
             }
         },
     });
@@ -122,14 +140,21 @@ AvroQueryClient.prototype.useDeleteBill = function () {
             return this.delete({ path: `/bill/${billId}` });
         },
         onMutate: async ({ billId }) => {
-            await queryClient.cancelQueries({ queryKey: ['bills'] });
-            const previousBills = queryClient.getQueryData(['bills']);
+            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 };
         },
+        onSuccess: async (_result, { billId }) => {
+            await this._syncEntity(queryClient, {
+                action: "delete",
+                entityKey: "bills",
+                id: billId,
+            });
+        },
         onError: (_err, _variables, context) => {
             if (context?.previousBills) {
-                queryClient.setQueryData(['bills'], context.previousBills);
+                queryClient.setQueryData(["bills"], context.previousBills);
             }
         },
     });
@@ -143,14 +168,20 @@ AvroQueryClient.prototype.useSyncBillToIntuit = function () {
             });
         },
         onMutate: async ({ billId }) => {
-            await queryClient.cancelQueries({ queryKey: ['bills', billId] });
-            const previousBill = queryClient.getQueryData(['bills', billId]);
+            await queryClient.cancelQueries({ queryKey: ["bills", billId] });
+            const previousBill = queryClient.getQueryData([
+                "bills",
+                billId,
+            ]);
             return { previousBill };
         },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ["bills"] });
+        },
         onError: (_err, variables, context) => {
             const { billId } = variables;
             if (context?.previousBill) {
-                queryClient.setQueryData(['bills', billId], context.previousBill);
+                queryClient.setQueryData(["bills", billId], context.previousBill);
             }
         },
     });
@@ -163,10 +194,15 @@ AvroQueryClient.prototype.useImportBillsFromIntuit = function () {
                 path: `/company/${this.companyId}/intuit/import`,
             });
         },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ["bills"] });
+        },
     });
 };
-AvroQueryClient.prototype.generatePDFFromBackend = function ({ billId }) {
-    return this.get({ path: `/company/${this.companyId}/bill/${billId}/pdf` }).then((response) => {
+AvroQueryClient.prototype.generatePDFFromBackend = function ({ billId, }) {
+    return this.get({
+        path: `/company/${this.companyId}/bill/${billId}/pdf`,
+    }).then((response) => {
         return response;
     });
 };
@@ -175,7 +211,7 @@ AvroQueryClient.prototype.sendBillingEmail = async function ({ subject, billId,
         path: `/bill/${billId}/email`,
         data: JSON.stringify({ recipients, subject, request_id }),
         headers: {
-            "Content-Type": "application/json"
-        }
+            "Content-Type": "application/json",
+        },
     });
 };

package/dist/client/hooks/catalog_items.js

@@ -1,5 +1,5 @@
-import { useQuery, useMutation } from '@tanstack/react-query';
-import { AvroQueryClient } from '../../client/QueryClient';
+import { useQuery, useMutation } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
 AvroQueryClient.prototype.useCreateCatalogItem = function () {
     const queryClient = this.getQueryClient();
     return useMutation({
@@ -8,18 +8,31 @@ AvroQueryClient.prototype.useCreateCatalogItem = function () {
                 path: `/company/${this.companyId}/catalog_item`,
                 data: JSON.stringify(data),
                 headers: {
-                    'Content-Type': 'application/json'
-                }
+                    "Content-Type": "application/json",
+                },
             });
         },
         onMutate: async () => {
-            await queryClient.cancelQueries({ queryKey: ['catalog_items', this.companyId] });
-            const previousItems = queryClient.getQueryData(['catalog_items', this.companyId]);
+            await queryClient.cancelQueries({
+                queryKey: ["catalog_items", this.companyId],
+            });
+            const previousItems = queryClient.getQueryData([
+                "catalog_items",
+                this.companyId,
+            ]);
             return { previousItems };
         },
+        onSuccess: async (result) => {
+            await this._syncEntity(queryClient, {
+                action: "create",
+                entityKey: "catalog_items",
+                id: result.id,
+                fetchPath: `/catalog_item/${result.id}`,
+            });
+        },
         onError: (_err, _variables, context) => {
             if (context?.previousItems) {
-                queryClient.setQueryData(['catalog_items', this.companyId], context.previousItems);
+                queryClient.setQueryData(["catalog_items", this.companyId], context.previousItems);
             }
         },
     });
@@ -27,22 +40,27 @@ AvroQueryClient.prototype.useCreateCatalogItem = function () {
 AvroQueryClient.prototype.useUpdateCatalogItem = function () {
     const queryClient = this.getQueryClient();
     return useMutation({
-        mutationFn: ({ catalogItemId, data }) => {
+        mutationFn: ({ catalogItemId, data, }) => {
             return this.put({
                 path: `/catalog_item/${catalogItemId}`,
                 data: JSON.stringify(data),
                 headers: {
                     "Content-Type": "application/json",
-                }
+                },
             });
         },
         onMutate: async ({ catalogItemId, data }) => {
-            await queryClient.cancelQueries({ queryKey: ['catalog_items'] });
-            await queryClient.cancelQueries({ queryKey: ['catalog_items', catalogItemId] });
-            const previousItems = queryClient.getQueryData(['catalog_items']);
-            const previousItem = queryClient.getQueryData(['catalog_items', catalogItemId]);
-            queryClient.setQueryData(['catalog_items', catalogItemId], (oldData) => oldData ? { ...oldData, ...data } : undefined);
-            queryClient.setQueriesData({ queryKey: ['catalog_items'] }, (oldData) => {
+            await queryClient.cancelQueries({ queryKey: ["catalog_items"] });
+            await queryClient.cancelQueries({
+                queryKey: ["catalog_items", catalogItemId],
+            });
+            const previousItems = queryClient.getQueryData(["catalog_items"]);
+            const previousItem = queryClient.getQueryData([
+                "catalog_items",
+                catalogItemId,
+            ]);
+            queryClient.setQueryData(["catalog_items", catalogItemId], (oldData) => oldData ? { ...oldData, ...data } : undefined);
+            queryClient.setQueriesData({ queryKey: ["catalog_items"] }, (oldData) => {
                 if (!oldData)
                     return oldData;
                 if (oldData.pages) {
@@ -58,20 +76,28 @@ AvroQueryClient.prototype.useUpdateCatalogItem = function () {
             });
             return { previousItems, previousItem };
         },
+        onSuccess: async (_result, { catalogItemId }) => {
+            await this._syncEntity(queryClient, {
+                action: "update",
+                entityKey: "catalog_items",
+                id: catalogItemId,
+                fetchPath: `/catalog_item/${catalogItemId}`,
+            });
+        },
         onError: (err, variables, context) => {
             const { catalogItemId } = variables;
             if (context?.previousItems) {
-                queryClient.setQueryData(['catalog_items'], context.previousItems);
+                queryClient.setQueryData(["catalog_items"], context.previousItems);
             }
             if (context?.previousItem) {
-                queryClient.setQueryData(['catalog_items', catalogItemId], context.previousItem);
+                queryClient.setQueryData(["catalog_items", catalogItemId], context.previousItem);
             }
         },
     });
 };
 AvroQueryClient.prototype.useGetCatalogItem = function (catalogItemId) {
     return useQuery({
-        queryKey: ['catalog_items', catalogItemId],
+        queryKey: ["catalog_items", catalogItemId],
         queryFn: () => this.get({ path: `/catalog_item/${catalogItemId}` }),
         enabled: Boolean(catalogItemId),
     });
@@ -80,16 +106,25 @@ AvroQueryClient.prototype.useDeleteCatalogItem = function () {
     const queryClient = this.getQueryClient();
     return useMutation({
         mutationFn: async ({ catalogItemId }) => {
-            return this.delete({ path: `/catalog_item/${catalogItemId}` });
+            return this.delete({
+                path: `/catalog_item/${catalogItemId}`,
+            });
         },
         onMutate: async ({ catalogItemId }) => {
-            await queryClient.cancelQueries({ queryKey: ['catalog_items'] });
-            const previousItems = queryClient.getQueryData(['catalog_items']);
+            await queryClient.cancelQueries({ queryKey: ["catalog_items"] });
+            const previousItems = queryClient.getQueryData(["catalog_items"]);
             return { previousItems };
         },
+        onSuccess: async (_result, { catalogItemId }) => {
+            await this._syncEntity(queryClient, {
+                action: "delete",
+                entityKey: "catalog_items",
+                id: catalogItemId,
+            });
+        },
         onError: (_err, _variables, context) => {
             if (context?.previousItems) {
-                queryClient.setQueryData(['catalog_items'], context.previousItems);
+                queryClient.setQueryData(["catalog_items"], context.previousItems);
             }
         },
     });

package/dist/client/hooks/chats.js

@@ -4,12 +4,12 @@ AvroQueryClient.prototype.useGetChats = function (body) {
     const queryClient = this.getQueryClient();
     const result = useInfiniteQuery({
         queryKey: [
-            'chats',
+            "chats",
             this.companyId,
             body.amt ?? 50,
             body.known_ids ?? [],
             body.unknown_ids ?? [],
-            body.query ?? '',
+            body.query ?? "",
         ],
         initialPageParam: 0,
         getNextPageParam: (lastPage, allPages) => {
@@ -22,7 +22,7 @@ AvroQueryClient.prototype.useGetChats = function (body) {
     if (result.data) {
         result.data.pages.forEach((data_page) => {
             data_page.forEach((chat) => {
-                queryClient.setQueryData(['chats', chat.id], chat);
+                queryClient.setQueryData(["chats", chat.id], chat);
             });
         });
     }
@@ -30,7 +30,7 @@ AvroQueryClient.prototype.useGetChats = function (body) {
 };
 AvroQueryClient.prototype.useGetChat = function (chatId) {
     return useQuery({
-        queryKey: ['chats', chatId],
+        queryKey: ["chats", chatId],
         queryFn: () => this.get({ path: `/chat/${chatId}` }),
         enabled: Boolean(chatId),
     });