@go-avro/avro-js 0.0.2-beta.4 → 0.0.2-beta.41

package/dist/client/core/xhr.js

@@ -0,0 +1,80 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { StandardError } from '../../types/error';
+AvroQueryClient.prototype._xhr = function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
+    const checkCancelled = () => {
+        if (cancelToken?.isCancelled()) {
+            return new StandardError(0, 'Request cancelled');
+        }
+        return null;
+    };
+    return new Promise((resolve, reject) => {
+        this.config.authManager.accessToken().then(token => {
+            const cancelErr = checkCancelled();
+            if (cancelErr)
+                return reject(cancelErr);
+            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 = () => {
+                const cancelErr = checkCancelled();
+                if (cancelErr)
+                    return reject(cancelErr);
+                if (xhr.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
+                    this.config.authManager
+                        .refreshTokens()
+                        .then(() => {
+                        this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
+                    })
+                        .catch(() => reject(new StandardError(401, 'Unauthorized (refresh failed)')));
+                    return;
+                }
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    try {
+                        resolve(JSON.parse(xhr.responseText));
+                    }
+                    catch {
+                        resolve(xhr.responseText);
+                    }
+                }
+                else {
+                    if (retryCount < this.config.maxRetries) {
+                        const delay = this.getDelay(this.config.retryStrategy, retryCount);
+                        setTimeout(() => {
+                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
+                        }, delay);
+                    }
+                    else {
+                        let msg = xhr.statusText;
+                        try {
+                            const parsed = JSON.parse(xhr.responseText);
+                            msg = parsed.msg || msg;
+                        }
+                        catch {
+                            console.warn('Failed to parse error response:', xhr.responseText);
+                        }
+                        reject(new StandardError(xhr.status, msg));
+                    }
+                }
+            };
+            xhr.onerror = () => {
+                if (retryCount < this.config.maxRetries) {
+                    const delay = this.getDelay(this.config.retryStrategy, retryCount);
+                    setTimeout(() => {
+                        this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
+                    }, delay);
+                }
+                else {
+                    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.send(body);
+        });
+    });
+};

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

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

package/dist/client/hooks/bills.js

@@ -0,0 +1,141 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { useQueryClient, useInfiniteQuery, useQuery, useMutation } from '@tanstack/react-query';
+AvroQueryClient.prototype.useGetBills = function (companyGuid, body) {
+    const queryClient = useQueryClient();
+    const result = useInfiniteQuery({
+        queryKey: [
+            'bills',
+            companyGuid,
+            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(companyGuid, { ...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 = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ companyId, data, }) => {
+            const body = {
+                events: data.line_items.filter(item => item.line_item_type === 'EVENT').map(item => item.id),
+                months: data.line_items.filter(item => item.line_item_type === 'SERVICE_MONTH').map(item => item.id),
+                line_items: data.line_items.filter(item => item.line_item_type === 'CUSTOM'),
+                manual_emails: data.custom_emails,
+                users: data.users,
+                due_date: data.due_date,
+            };
+            return this.post(`/company/${companyId}/bill`, JSON.stringify(body), undefined, {
+                'Content-Type': 'application/json',
+            });
+        },
+        onMutate: async ({ companyId }) => {
+            await queryClient.cancelQueries({ queryKey: ['bills', companyId] });
+            const previousBills = queryClient.getQueryData(['bills', 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, variables) => {
+            queryClient.invalidateQueries({ queryKey: ['bills', variables.companyId] });
+            queryClient.invalidateQueries({ queryKey: ['events', variables.companyId] });
+            queryClient.invalidateQueries({ queryKey: ['months', variables.companyId] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateBill = function () {
+    const queryClient = useQueryClient();
+    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 = useQueryClient();
+    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'] });
+        },
+    });
+};

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

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

package/dist/client/hooks/companies.js

@@ -0,0 +1,51 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+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.useUpdateCompany = function () {
+    const queryClient = useQueryClient();
+    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'] });
+        },
+    });
+};

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

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

package/dist/client/hooks/events.js

@@ -0,0 +1,147 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { useQueryClient, useInfiniteQuery, useQuery, useMutation } from '@tanstack/react-query';
+AvroQueryClient.prototype.useGetEvents = function (companyGuid, body) {
+    const queryClient = useQueryClient();
+    const result = useInfiniteQuery({
+        queryKey: [
+            'events',
+            companyGuid,
+            body.amt ?? 50,
+            body.known_ids ?? [],
+            body.unknown_ids ?? [],
+            body.query ?? '',
+            body.unbilled ?? true,
+            body.billed ?? true,
+            body.paid ?? true,
+            body.jobId ?? '',
+        ],
+        initialPageParam: 0,
+        getNextPageParam: (lastPage, allPages) => {
+            if (lastPage.length < (body.amt ?? 50))
+                return undefined;
+            return allPages.flat().length; // next offset
+        },
+        queryFn: ({ pageParam = 0 }) => this.fetchEvents(companyGuid, { ...body, offset: pageParam }),
+    });
+    if (result.data) {
+        result.data.pages.forEach((data_page) => {
+            data_page.forEach((event) => {
+                queryClient.setQueryData(['event', event.id], event);
+            });
+        });
+    }
+    return result;
+};
+AvroQueryClient.prototype.useGetEvent = function (eventId) {
+    return useQuery({
+        queryKey: ['event', eventId],
+        queryFn: () => this.get(`/event/${eventId}`),
+        enabled: Boolean(eventId),
+    });
+};
+AvroQueryClient.prototype.useUpdateEvents = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ companyId, events, action, }) => {
+            const eventIds = events.map(event => event.id);
+            return this.put(`/company/${companyId}/events`, JSON.stringify({
+                events: eventIds,
+                billed: true,
+                paid: action === "paid",
+            }), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ events, action }) => {
+            await queryClient.cancelQueries({ queryKey: ['events'] });
+            await queryClient.cancelQueries({ queryKey: ['event'] });
+            const previousEvents = queryClient.getQueryData(['events']);
+            const previousEventObjs = events.map(event => queryClient.getQueryData(['event', event.id]));
+            const eventIds = events.map(event => event.id);
+            // Optimistically update individual event cache
+            eventIds.forEach((eventId, idx) => {
+                queryClient.setQueryData(['event', eventId], (oldData) => {
+                    return oldData
+                        ? { ...oldData, billed: true, paid: action === "paid" }
+                        : oldData;
+                });
+            });
+            // Optimistically update events list cache
+            queryClient.setQueriesData({ queryKey: ['events'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.map((event) => eventIds.includes(event.id)
+                        ? { ...event, billed: true, paid: action === "paid" }
+                        : event));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((event) => eventIds.includes(event.id)
+                        ? { ...event, billed: true, paid: action === "paid" }
+                        : event);
+                }
+                return oldData;
+            });
+            return { previousEvents, previousEventObjs };
+        },
+        onError: (err, variables, context) => {
+            if (context?.previousEvents) {
+                queryClient.setQueryData(['events'], context.previousEvents);
+            }
+            if (context?.previousEventObjs) {
+                context.previousEventObjs.forEach((eventObj) => {
+                    queryClient.setQueryData(['event', eventObj.id], eventObj);
+                });
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['events'] });
+            queryClient.invalidateQueries({ queryKey: ['event'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteEvent = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ eventId, }) => {
+            return this.delete(`/event/${eventId}`, undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ eventId }) => {
+            await queryClient.cancelQueries({ queryKey: ['events'] });
+            await queryClient.cancelQueries({ queryKey: ['event', eventId] });
+            const previousEvents = queryClient.getQueryData(['events']);
+            const previousEvent = queryClient.getQueryData(['event', eventId]);
+            queryClient.setQueryData(['event', eventId], undefined);
+            queryClient.setQueriesData({ queryKey: ['events'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.filter((event) => event.id !== eventId));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.filter((event) => event.id !== eventId);
+                }
+                return oldData;
+            });
+            return { previousEvents, previousEvent };
+        },
+        onError: (_err, variables, context) => {
+            const { eventId } = variables;
+            if (context?.previousEvents) {
+                queryClient.setQueryData(['events'], context.previousEvents);
+            }
+            if (context?.previousEvent) {
+                queryClient.setQueryData(['event', eventId], context.previousEvent);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { eventId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['events'] });
+            queryClient.invalidateQueries({ queryKey: ['event', eventId] });
+        },
+    });
+};

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

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

package/dist/client/hooks/jobs.js

@@ -0,0 +1,184 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+AvroQueryClient.prototype.useGetJobs = function (companyGuid, body, total = 0, onProgress, isMainLoad = false) {
+    const queryClient = useQueryClient();
+    return useQuery({
+        queryKey: [isMainLoad ? 'main' : 'jobs', companyGuid, body.amt ?? 50, body.query ?? ""],
+        queryFn: async () => {
+            if (total === 0) {
+                onProgress?.(1);
+                return [];
+            }
+            onProgress?.(0);
+            const pageCount = body.amt ? Math.ceil(total / body.amt) : 0;
+            let completed = 0;
+            const promises = Array.from({ length: pageCount }, (_, i) => this.fetchJobs(companyGuid, {
+                ...body,
+                offset: i * (body.amt ?? 0),
+            }));
+            const trackedPromises = promises.map((promise) => promise.then((result) => {
+                completed++;
+                const fraction = completed / pageCount;
+                onProgress?.(fraction);
+                return result;
+            }));
+            const pages = await Promise.all(trackedPromises);
+            const jobs = pages.flat();
+            jobs.forEach((job) => {
+                job.last_event = job.tasks.reduce((latest, task) => {
+                    return task.last_event && (!latest || task.last_event.time_started > latest.time_started) ? task.last_event : latest;
+                }, null);
+                job.last_completed_event = job.tasks.reduce((latest, task) => {
+                    return task.last_completed_event && (!latest || task.last_completed_event.time_started > latest.time_started) ? task.last_completed_event : latest;
+                }, null);
+                job.overdue_time = job.tasks.reduce((maxOverdue, task) => {
+                    return task.overdue_time && task.overdue_time > maxOverdue ? task.overdue_time : maxOverdue;
+                }, 0);
+                queryClient.setQueryData(['job', job.id], job);
+            });
+            if (isMainLoad) {
+                queryClient.setQueryData(['jobs', companyGuid, body.amt ?? 50, body.query ?? ""], jobs);
+            }
+            return jobs;
+        },
+        enabled: Boolean(companyGuid) && companyGuid.length > 0 && Boolean(total) && total >= 0,
+        ...isMainLoad ? { staleTime: Infinity, cacheTime: Infinity } : {},
+    });
+};
+AvroQueryClient.prototype.useGetJob = function (jobId) {
+    return useQuery({
+        queryKey: ['job', jobId],
+        queryFn: () => this.get(`/job/${jobId}`),
+        enabled: Boolean(jobId),
+    });
+};
+AvroQueryClient.prototype.useCreateJob = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ companyId, jobData }) => {
+            return this.post(`/company/${companyId}/job`, JSON.stringify(jobData), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ companyId, jobData }) => {
+            await queryClient.cancelQueries({ queryKey: ['jobs'] });
+            const previousJobs = queryClient.getQueryData(['jobs']);
+            queryClient.setQueryData(['jobs'], (oldData) => {
+                if (!oldData)
+                    return [jobData];
+                if (oldData.pages) {
+                    const firstPage = oldData.pages[0] || [];
+                    return {
+                        ...oldData,
+                        pages: [[jobData, ...firstPage], ...oldData.pages.slice(1)],
+                    };
+                }
+                if (Array.isArray(oldData)) {
+                    return [jobData, ...oldData];
+                }
+                return oldData;
+            });
+            return { previousJobs };
+        },
+        onError: (err, variables, context) => {
+            if (context?.previousJobs) {
+                queryClient.setQueryData(['jobs'], context.previousJobs);
+            }
+        },
+        onSettled: (data, error, variables) => {
+            const { id: jobId } = data ?? {};
+            queryClient.invalidateQueries({ queryKey: ['jobs'] });
+            queryClient.invalidateQueries({ queryKey: ['job', jobId] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateJob = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ jobId, updates }) => {
+            return this.put(`/job/${jobId}`, JSON.stringify(updates), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ jobId, updates }) => {
+            await queryClient.cancelQueries({ queryKey: ['jobs'] });
+            await queryClient.cancelQueries({ queryKey: ['job', jobId] });
+            const previousJobs = queryClient.getQueryData(['jobs']);
+            const previousJob = queryClient.getQueryData(['job', jobId]);
+            queryClient.setQueryData(['job', jobId], (oldData) => oldData ? { ...oldData, ...updates } : undefined);
+            queryClient.setQueriesData({ queryKey: ['jobs'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    return {
+                        ...oldData,
+                        pages: oldData.pages.map((page) => page.map((job) => job.id === jobId ? { ...job, ...updates } : job)),
+                    };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((job) => job.id === jobId ? { ...job, ...updates } : job);
+                }
+                return oldData;
+            });
+            return { previousJobs, previousJob };
+        },
+        onError: (err, variables, context) => {
+            const { jobId } = variables;
+            if (context?.previousJobs) {
+                queryClient.setQueryData(['jobs'], context.previousJobs);
+            }
+            if (context?.previousJob) {
+                queryClient.setQueryData(['job', jobId], context.previousJob);
+            }
+        },
+        onSettled: (data, error, variables) => {
+            const { jobId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['jobs'] });
+            queryClient.invalidateQueries({ queryKey: ['job', jobId] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteJob = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ jobId }) => {
+            return this.delete(`/job/${jobId}`, undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ jobId }) => {
+            await queryClient.cancelQueries({ queryKey: ['jobs'] });
+            await queryClient.cancelQueries({ queryKey: ['job', jobId] });
+            const previousJobs = queryClient.getQueryData(['jobs']);
+            const previousJob = queryClient.getQueryData(['job', jobId]);
+            queryClient.setQueryData(['job', jobId], undefined);
+            queryClient.setQueriesData({ queryKey: ['jobs'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.filter((job) => job.id !== jobId));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.filter((job) => job.id !== jobId);
+                }
+                return oldData;
+            });
+            return { previousJobs, previousJob };
+        },
+        onError: (_err, variables, context) => {
+            const { jobId } = variables;
+            if (context?.previousJobs) {
+                queryClient.setQueryData(['jobs'], context.previousJobs);
+            }
+            if (context?.previousJob) {
+                queryClient.setQueryData(['job', jobId], context.previousJob);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { jobId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['jobs'] });
+            queryClient.invalidateQueries({ queryKey: ['job', jobId] });
+        },
+    });
+};

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

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