@go-avro/avro-js 0.0.2-beta.17 → 0.0.2-beta.170

package/dist/client/hooks/companies.js

@@ -0,0 +1,185 @@
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+import { AuthState } from '../../types/auth';
+AvroQueryClient.prototype.useGetCompanies = function (options = {}) {
+    return useQuery({
+        queryKey: ['/company/list'],
+        queryFn: () => {
+            const companiesPromise = this.get(`/company/list`);
+            companiesPromise.then((companies) => {
+                if (!companies.find((c) => c.id === this.companyId) && companies.length > 0) {
+                    this.companyId = companies[0].id;
+                }
+            });
+            return companiesPromise;
+        },
+        enabled: this.getAuthState() === AuthState.AUTHENTICATED,
+        ...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) {
+                this.companyId = await this.config.authManager.getCompanyId();
+            }
+            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;
+        },
+        enabled: this.getAuthState() === AuthState.AUTHENTICATED,
+    });
+};
+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.useCreateUserCompany = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ user_id, data }) => {
+            if (!user_id) {
+                throw new Error("Both userId and companyId are required");
+            }
+            return this.post(`/company/${this.companyId}/user/${user_id}`, JSON.stringify(data), undefined, { "Content-Type": "application/json" });
+        },
+        onMutate: async ({ user_id }) => {
+            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 || []), { id: user_id }],
+                };
+            });
+            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] });
+            queryClient.invalidateQueries({ queryKey: ['/company/list'] });
+            queryClient.invalidateQueries({ queryKey: ['company', 'current'] });
+        },
+    });
+};
+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 {};

package/dist/client/hooks/events.js

@@ -0,0 +1,308 @@
+import { useInfiniteQuery, useQuery, useMutation } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useGetEvents = function (body) {
+    const queryClient = this.getQueryClient();
+    const result = useInfiniteQuery({
+        queryKey: [
+            'events',
+            this.companyId,
+            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({ ...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.useCreateEvent = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: ({ eventData }) => {
+            return this.post(`/company/${this.companyId}/event`, JSON.stringify(eventData), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ eventData }) => {
+            await queryClient.cancelQueries({ queryKey: ['events'] });
+            const previousEvents = queryClient.getQueryData(['events']);
+            const previousJob = queryClient.getQueryData(['job', eventData.job_id]);
+            const previousJobs = queryClient.getQueryData(['jobs']);
+            if (previousJob) {
+                const updatedJob = {
+                    ...previousJob,
+                    current_event: eventData,
+                    last_completed_event: (eventData.time_ended ?? -1) > -1 ? eventData : previousJob.last_completed_event,
+                };
+                updatedJob.tasks = previousJob.tasks.map((task) => {
+                    if (eventData.tasks?.includes(task.id)) {
+                        return {
+                            ...task,
+                            current_event: eventData,
+                            last_completed_event: (eventData.time_ended ?? -1) > -1 ? eventData : task.last_completed_event,
+                        };
+                    }
+                    return task;
+                });
+                const updatedJobs = previousJobs?.map((job) => job.id === updatedJob.id ? updatedJob : job);
+                queryClient.setQueryData(['job', previousJob.id], updatedJob);
+                queryClient.setQueryData(['jobs'], updatedJobs);
+            }
+            queryClient.setQueryData(['events'], (oldData) => {
+                if (!oldData)
+                    return [];
+                if (oldData.pages) {
+                    const firstPage = oldData.pages[0] || [];
+                    return {
+                        ...oldData,
+                        pages: [
+                            [
+                                {
+                                    ...eventData,
+                                    id: Math.random().toString(36).substring(2, 11),
+                                    company_id: this.companyId,
+                                },
+                                ...firstPage,
+                            ],
+                            ...oldData.pages.slice(1),
+                        ],
+                    };
+                }
+                if (Array.isArray(oldData)) {
+                    return [
+                        {
+                            ...eventData,
+                            id: Math.random().toString(36).substring(2, 11),
+                            company_id: this.companyId,
+                        },
+                        ...oldData,
+                    ];
+                }
+                return oldData;
+            });
+            return { previousEvents, previousJob, previousJobs };
+        },
+        onError: (err, variables, context) => {
+            if (context?.previousEvents) {
+                queryClient.setQueryData(['events'], context.previousEvents);
+            }
+            if (context?.previousJob) {
+                queryClient.setQueryData(['job', context.previousJob.id], context.previousJob);
+            }
+            if (context?.previousJobs) {
+                queryClient.setQueryData(['jobs'], context.previousJobs);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['events'] });
+            queryClient.invalidateQueries({ queryKey: ['job'] });
+            queryClient.invalidateQueries({ queryKey: ['jobs'] });
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateEvent = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: ({ eventId, updates }) => {
+            return this.put(`/event/${eventId}`, JSON.stringify(updates), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ eventId, updates }) => {
+            await queryClient.cancelQueries({ queryKey: ['event', eventId] });
+            await queryClient.cancelQueries({ queryKey: ['events'] });
+            const previousEvent = queryClient.getQueryData(['event', eventId]);
+            const previousEvents = queryClient.getQueryData(['events']);
+            const previousJob = queryClient.getQueryData(['job', previousEvent?.job_id]);
+            const previousJobs = queryClient.getQueryData(['jobs']);
+            if (previousJob) {
+                const updatedJob = {
+                    ...previousJob,
+                    current_event: previousEvent ? { ...previousEvent, ...updates } : previousJob.current_event,
+                    last_completed_event: (updates.time_ended ?? -1) > -1 && previousEvent ? { ...previousEvent, ...updates } : previousJob.last_completed_event,
+                };
+                updatedJob.tasks = previousJob.tasks.map((task) => {
+                    if (updates.tasks?.includes(task.id)) {
+                        return {
+                            ...task,
+                            current_event: previousEvent ? { ...previousEvent, ...updates } : task.current_event,
+                            last_completed_event: (updates.time_ended ?? -1) > -1 ? (previousEvent ? { ...previousEvent, ...updates } : task.last_completed_event) : task.last_completed_event,
+                            overdue_time: -task.frequency - task.delay,
+                        };
+                    }
+                    return task;
+                });
+                const updatedJobs = previousJobs?.map((job) => job.id === updatedJob.id ? updatedJob : job);
+                queryClient.setQueryData(['job', previousJob.id], updatedJob);
+                queryClient.setQueryData(['jobs'], updatedJobs);
+            }
+            queryClient.setQueryData(['event', eventId], (oldData) => oldData ? { ...oldData, ...updates } : undefined);
+            queryClient.setQueriesData({ queryKey: ['events'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.map((event) => event.id === eventId ? { ...event, ...updates } : event));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((event) => event.id === eventId ? { ...event, ...updates } : event);
+                }
+                return oldData;
+            });
+            return { previousEvent, previousEvents, previousJob, previousJobs };
+        },
+        onError: (_err, variables, context) => {
+            const { eventId } = variables;
+            if (context?.previousEvent) {
+                queryClient.setQueryData(['event', eventId], context.previousEvent);
+            }
+            if (context?.previousEvents) {
+                queryClient.setQueryData(['events'], context.previousEvents);
+            }
+            if (context?.previousJob) {
+                queryClient.setQueryData(['job', context.previousJob.id], context.previousJob);
+            }
+            if (context?.previousJobs) {
+                queryClient.setQueryData(['jobs'], context.previousJobs);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { eventId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['event', eventId] });
+            queryClient.invalidateQueries({ queryKey: ['events'] });
+            queryClient.invalidateQueries({ queryKey: ['job'] });
+            queryClient.invalidateQueries({ queryKey: ['jobs'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateEvents = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ events, action, }) => {
+            const eventIds = events.map(event => event.id);
+            return this.put(`/company/${this.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 = this.getQueryClient();
+    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/groups.d.ts

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

package/dist/client/hooks/groups.js

@@ -0,0 +1,130 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetGroups = function (body, total, onProgress) {
+    return useQuery({
+        queryKey: ['groups', this.companyId, body.amt ?? 50, body.query ?? "", total ?? "all"],
+        queryFn: async () => {
+            if (typeof total !== "number") {
+                return this.fetchGroups({ ...body, offset: 0 });
+            }
+            onProgress?.(0);
+            const pageCount = body.amt ? Math.ceil(total / body.amt) + 1 : 1;
+            let completed = 0;
+            const promises = Array.from({ length: pageCount }, (_, i) => this.fetchGroups({
+                ...body,
+                offset: i * (body.amt ?? 1),
+            }));
+            const trackedPromises = promises.map((promise) => promise.then((result) => {
+                completed++;
+                const fraction = completed / pageCount;
+                onProgress?.(fraction);
+                return result;
+            }));
+            const pages = await Promise.all(trackedPromises);
+            const groups = pages.flat();
+            return groups;
+        },
+    });
+};
+AvroQueryClient.prototype.useCreateGroup = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ groupData }) => {
+            return this.post(`/company/${this.companyId}/group`, JSON.stringify(groupData), undefined, { "Content-Type": "application/json" });
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+            queryClient.invalidateQueries({ queryKey: ['groups'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateGroup = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ groupId, groupData }) => {
+            return this.put(`/group/${groupId}`, JSON.stringify(groupData), undefined, { "Content-Type": "application/json" });
+        },
+        onMutate: async ({ groupId, groupData }) => {
+            await queryClient.cancelQueries({ queryKey: ['groups'] });
+            await queryClient.cancelQueries({ queryKey: ['group', groupId] });
+            const previousGroups = queryClient.getQueryData(['groups']);
+            const previousGroup = queryClient.getQueryData(['group', groupId]);
+            queryClient.setQueryData(['group', groupId], (oldData) => {
+                if (!oldData)
+                    return oldData;
+                return { ...oldData, ...groupData };
+            });
+            queryClient.setQueriesData({ queryKey: ['groups'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.map((group) => group.id === groupId ? { ...group, ...groupData } : group));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((group) => group.id === groupId ? { ...group, ...groupData } : group);
+                }
+                return oldData;
+            });
+            return { previousGroups, previousGroup };
+        },
+        onError: (_err, variables, context) => {
+            const { groupId } = variables;
+            if (context?.previousGroups) {
+                queryClient.setQueryData(['groups'], context.previousGroups);
+            }
+            if (context?.previousGroup) {
+                queryClient.setQueryData(['group', groupId], context.previousGroup);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { groupId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['groups'] });
+            queryClient.invalidateQueries({ queryKey: ['group', groupId] });
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteGroup = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ groupId, }) => {
+            return this.delete(`/group/${groupId}`);
+        },
+        onMutate: async ({ groupId }) => {
+            await queryClient.cancelQueries({ queryKey: ['groups'] });
+            await queryClient.cancelQueries({ queryKey: ['group', groupId] });
+            const previousGroups = queryClient.getQueryData(['groups']);
+            const previousGroup = queryClient.getQueryData(['group', groupId]);
+            queryClient.setQueryData(['group', groupId], undefined);
+            queryClient.setQueriesData({ queryKey: ['groups'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.filter((group) => group.id !== groupId));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.filter((group) => group.id !== groupId);
+                }
+                return oldData;
+            });
+            return { previousGroups, previousGroup };
+        },
+        onError: (_err, variables, context) => {
+            const { groupId } = variables;
+            if (context?.previousGroups) {
+                queryClient.setQueryData(['groups'], context.previousGroups);
+            }
+            if (context?.previousGroup) {
+                queryClient.setQueryData(['group', groupId], context.previousGroup);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { groupId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['groups'] });
+            queryClient.invalidateQueries({ queryKey: ['group', groupId] });
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+        },
+    });
+};

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

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