@go-avro/avro-js 0.0.42 → 0.0.44

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) {
@@ -30,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();
@@ -59,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);
     }
@@ -68,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,12 +1,12 @@
-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}`);

package/dist/client/core/xhr.js

@@ -1,10 +1,10 @@
-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++) {
@@ -19,14 +19,14 @@ AvroQueryClient.prototype._xhr = async function (method, path, body, cancelToken
                 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;
                             }
@@ -47,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) => {
@@ -65,37 +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");
+                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);
@@ -103,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

@@ -1,47 +1,47 @@
-import { useQuery } from "@tanstack/react-query";
-import { AvroQueryClient } from "../../client/QueryClient";
+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, }) {
     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

@@ -1,9 +1,9 @@
-import { useQuery } from "@tanstack/react-query";
-import { AvroQueryClient } from "../../client/QueryClient";
+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,12 +1,12 @@
-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.query ?? '',
             body.known_ids ?? [],
             body.unknown_ids ?? [],
             body.paid ?? false,
@@ -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,29 +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],
+                queryKey: ['bills', this.companyId],
             });
-            const previousBills = queryClient.getQueryData(["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",
+                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);
             }
         },
     });
@@ -83,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",
+                    '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) {
@@ -116,8 +116,8 @@ AvroQueryClient.prototype.useUpdateBill = function () {
         },
         onSuccess: async (_result, { billId }) => {
             await this._syncEntity(queryClient, {
-                action: "update",
-                entityKey: "bills",
+                action: 'update',
+                entityKey: 'bills',
                 id: billId,
                 fetchPath: `/bill/${billId}`,
             });
@@ -125,10 +125,10 @@ AvroQueryClient.prototype.useUpdateBill = function () {
         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);
             }
         },
     });
@@ -140,21 +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",
+                action: 'delete',
+                entityKey: 'bills',
                 id: billId,
             });
         },
         onError: (_err, _variables, context) => {
             if (context?.previousBills) {
-                queryClient.setQueryData(["bills"], context.previousBills);
+                queryClient.setQueryData(['bills'], context.previousBills);
             }
         },
     });
@@ -168,20 +168,17 @@ 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"] });
+            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);
             }
         },
     });
@@ -195,11 +192,11 @@ AvroQueryClient.prototype.useImportBillsFromIntuit = function () {
             });
         },
         onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ["bills"] });
+            queryClient.invalidateQueries({ queryKey: ['bills'] });
         },
     });
 };
-AvroQueryClient.prototype.generatePDFFromBackend = function ({ billId, }) {
+AvroQueryClient.prototype.generatePDFFromBackend = function ({ billId }) {
     return this.get({
         path: `/company/${this.companyId}/bill/${billId}/pdf`,
     }).then((response) => {
@@ -211,7 +208,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,31 +8,28 @@ 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],
+                queryKey: ['catalog_items', this.companyId],
             });
-            const previousItems = queryClient.getQueryData([
-                "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",
+                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);
             }
         },
     });
@@ -45,22 +42,19 @@ AvroQueryClient.prototype.useUpdateCatalogItem = function () {
                 path: `/catalog_item/${catalogItemId}`,
                 data: JSON.stringify(data),
                 headers: {
-                    "Content-Type": "application/json",
+                    'Content-Type': 'application/json',
                 },
             });
         },
         onMutate: async ({ catalogItemId, data }) => {
-            await queryClient.cancelQueries({ queryKey: ["catalog_items"] });
+            await queryClient.cancelQueries({ queryKey: ['catalog_items'] });
             await queryClient.cancelQueries({
-                queryKey: ["catalog_items", catalogItemId],
+                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) => {
+            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) {
@@ -78,8 +72,8 @@ AvroQueryClient.prototype.useUpdateCatalogItem = function () {
         },
         onSuccess: async (_result, { catalogItemId }) => {
             await this._syncEntity(queryClient, {
-                action: "update",
-                entityKey: "catalog_items",
+                action: 'update',
+                entityKey: 'catalog_items',
                 id: catalogItemId,
                 fetchPath: `/catalog_item/${catalogItemId}`,
             });
@@ -87,17 +81,17 @@ AvroQueryClient.prototype.useUpdateCatalogItem = function () {
         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),
     });
@@ -111,20 +105,20 @@ AvroQueryClient.prototype.useDeleteCatalogItem = function () {
             });
         },
         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",
+                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

@@ -1,15 +1,15 @@
-import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
-import { AvroQueryClient } from "../../client/QueryClient";
+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",
+            '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),
     });