@go-avro/avro-js 0.0.2-beta.14 → 0.0.2-beta.140

package/dist/client/hooks/messages.js

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

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

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

package/dist/client/hooks/months.js

@@ -0,0 +1,93 @@
+import { useInfiniteQuery, useMutation } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useGetMonths = function (body) {
+    const queryClient = this.getQueryClient();
+    const result = useInfiniteQuery({
+        queryKey: [
+            'months',
+            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.fetchMonths({ ...body, offset: pageParam }),
+    });
+    if (result.data) {
+        result.data.pages.forEach((data_page) => {
+            data_page.forEach((month) => {
+                queryClient.setQueryData(['month', month.id], month);
+            });
+        });
+    }
+    return result;
+};
+AvroQueryClient.prototype.useUpdateMonths = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ months, action, }) => {
+            const monthIds = months.map(month => month.id);
+            return this.put(`/company/${this.companyId}/months`, JSON.stringify({
+                months: monthIds,
+                billed: true,
+                paid: action === "paid",
+            }), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ months, action }) => {
+            await queryClient.cancelQueries({ queryKey: ['months'] });
+            await queryClient.cancelQueries({ queryKey: ['month'] });
+            const previousMonths = queryClient.getQueryData(['months']);
+            const previousMonthObjs = months.map(month => queryClient.getQueryData(['month', month.id]));
+            const monthIds = months.map(month => month.id);
+            monthIds.forEach((monthId, idx) => {
+                queryClient.setQueryData(['month', monthId], (oldData) => {
+                    return oldData
+                        ? { ...oldData, billed: true, paid: action === "paid" }
+                        : oldData;
+                });
+            });
+            queryClient.setQueriesData({ queryKey: ['months'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.map((month) => monthIds.includes(month.id)
+                        ? { ...month, billed: true, paid: action === "paid" }
+                        : month));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((month) => monthIds.includes(month.id)
+                        ? { ...month, billed: true, paid: action === "paid" }
+                        : month);
+                }
+                return oldData;
+            });
+            return { previousMonths, previousMonthObjs };
+        },
+        onError: (err, variables, context) => {
+            if (context) {
+                queryClient.setQueryData(['months'], context.previousMonths);
+                context.previousMonthObjs.forEach((monthObj) => {
+                    queryClient.setQueryData(['month', monthObj.id], monthObj);
+                });
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['months'] });
+            queryClient.invalidateQueries({ queryKey: ['month'] });
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+        },
+    });
+};

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

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

package/dist/client/hooks/plans.js

@@ -0,0 +1,8 @@
+import { useQuery } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetPlans = function (code) {
+    return useQuery({
+        queryKey: ['plans', code],
+        queryFn: async () => this.get(`/plans${code ? `?code=${code}` : ''}`),
+    });
+};

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

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

package/dist/client/hooks/root.js

@@ -0,0 +1,8 @@
+import { useQuery } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useGetRoot = function () {
+    return useQuery({
+        queryKey: ['health'],
+        queryFn: () => this.get('/'),
+    });
+};

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

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

package/dist/client/hooks/routes.js

@@ -0,0 +1,167 @@
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useGetRoutes = function (body, total, onProgress) {
+    return useQuery({
+        queryKey: ['routes', this.companyId, body.amt ?? 50, body.query ?? "", total ?? "all"],
+        queryFn: async () => {
+            if (typeof total !== "number") {
+                return this.fetchRoutes({ ...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.fetchRoutes({
+                ...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 routes = pages.flat();
+            return routes;
+        },
+    });
+};
+AvroQueryClient.prototype.useGetRoute = function (routeId) {
+    const queryClient = this.getQueryClient();
+    return useQuery({
+        queryKey: ['route', routeId],
+        queryFn: () => this.get(`/route/${routeId}`),
+        enabled: Boolean(routeId) && routeId.length > 0,
+    });
+};
+AvroQueryClient.prototype.useCreateRoute = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ routeData }) => {
+            return this.post(`/company/${this.companyId}/route`, JSON.stringify(routeData), undefined, { "Content-Type": "application/json" });
+        },
+        onMutate: async ({ routeData }) => {
+            await queryClient.cancelQueries({ queryKey: ['routes'] });
+            const previousRoutes = queryClient.getQueryData(['routes']);
+            queryClient.setQueriesData({ queryKey: ['routes'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    return {
+                        ...oldData,
+                        pages: [
+                            [{ ...routeData, id: 'temp-id' }],
+                            ...oldData.pages,
+                        ],
+                    };
+                }
+                if (Array.isArray(oldData)) {
+                    return [{ ...routeData, id: 'temp-id' }, ...oldData];
+                }
+                return oldData;
+            });
+            return { previousRoutes };
+        },
+        onError: (_err, _variables, context) => {
+            if (context?.previousRoutes) {
+                queryClient.setQueryData(['routes'], context.previousRoutes);
+            }
+        },
+        onSettled: (_data, _error, _variables) => {
+            queryClient.invalidateQueries({ queryKey: ['routes'] });
+            queryClient.invalidateQueries({ queryKey: ['jobs'] });
+            queryClient.invalidateQueries({ queryKey: ['job'] });
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateRoute = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ routeId, updates, }) => {
+            return this.put(`/route/${routeId}`, JSON.stringify(updates), undefined, { "Content-Type": "application/json" });
+        },
+        onMutate: async ({ routeId, updates }) => {
+            await queryClient.cancelQueries({ queryKey: ['route', routeId] });
+            await queryClient.cancelQueries({ queryKey: ['routes'] });
+            const previousRoute = queryClient.getQueryData(['route', routeId]);
+            const previousRoutes = queryClient.getQueryData(['routes']);
+            queryClient.setQueryData(['route', routeId], (oldData) => oldData ? { ...oldData, ...updates } : undefined);
+            queryClient.setQueriesData({ queryKey: ['routes'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    return {
+                        ...oldData,
+                        pages: oldData.pages.map((page) => page.map((route) => route.id === routeId ? { ...route, ...updates } : route)),
+                    };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((route) => route.id === routeId ? { ...route, ...updates } : route);
+                }
+                return oldData;
+            });
+            return { previousRoute, previousRoutes };
+        },
+        onError: (_err, variables, context) => {
+            const { routeId } = variables;
+            if (context?.previousRoute) {
+                queryClient.setQueryData(['route', routeId], context.previousRoute);
+            }
+            if (context?.previousRoutes) {
+                queryClient.setQueryData(['routes'], context.previousRoutes);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { routeId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['routes'] });
+            queryClient.invalidateQueries({ queryKey: ['jobs'] });
+            queryClient.invalidateQueries({ queryKey: ['route', routeId] });
+            queryClient.invalidateQueries({ queryKey: ['job'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteRoute = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ routeId, }) => {
+            return this.delete(`/route/${routeId}`);
+        },
+        onMutate: async ({ routeId }) => {
+            await queryClient.cancelQueries({ queryKey: ['routes'] });
+            await queryClient.cancelQueries({ queryKey: ['route', routeId] });
+            const previousRoutes = queryClient.getQueryData(['routes']);
+            const previousRoute = queryClient.getQueryData(['route', routeId]);
+            queryClient.setQueryData(['route', routeId], undefined);
+            queryClient.setQueriesData({ queryKey: ['routes'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.filter((route) => route.id !== routeId));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.filter((route) => route.id !== routeId);
+                }
+                return oldData;
+            });
+            return { previousRoutes, previousRoute };
+        },
+        onError: (_err, variables, context) => {
+            const { routeId } = variables;
+            if (context?.previousRoutes) {
+                queryClient.setQueryData(['routes'], context.previousRoutes);
+            }
+            if (context?.previousRoute) {
+                queryClient.setQueryData(['route', routeId], context.previousRoute);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { routeId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['routes'] });
+            queryClient.invalidateQueries({ queryKey: ['jobs'] });
+            queryClient.invalidateQueries({ queryKey: ['route', routeId] });
+            queryClient.invalidateQueries({ queryKey: ['job'] });
+        },
+    });
+};

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

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

package/dist/client/hooks/sessions.js

@@ -0,0 +1,175 @@
+import { useMutation, useQuery, useInfiniteQuery } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetUserSessions = function () {
+    return useQuery({
+        queryKey: ['sessions'],
+        queryFn: () => this.get('/session'),
+    });
+};
+AvroQueryClient.prototype.useCreateUserSession = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: ({ sessionData }) => {
+            return this.post(`/company/${this.companyId}/session`, JSON.stringify(sessionData), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ sessionData }) => {
+            await queryClient.cancelQueries({ queryKey: ['sessions'] });
+            const previousSessions = queryClient.getQueryData(['sessions']);
+            queryClient.setQueryData(['sessions'], (oldData) => {
+                if (!oldData)
+                    return [];
+                if (Array.isArray(oldData)) {
+                    return [
+                        ...oldData,
+                        {
+                            ...sessionData,
+                            id: Math.random().toString(36).substr(2, 9),
+                            company_id: this.companyId,
+                        }
+                    ];
+                }
+                return oldData;
+            });
+            return { previousSessions };
+        },
+        onError: (err, variables, context) => {
+            if (context?.previousSessions) {
+                queryClient.setQueryData(['sessions'], context.previousSessions);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['sessions'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useCreateSessionBreak = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: ({ sessionId, breakData }) => {
+            return this.post(`/session/${sessionId}/break`, JSON.stringify(breakData), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ sessionId, breakData }) => {
+            await queryClient.cancelQueries({ queryKey: ['sessions'] });
+            const previousSessions = queryClient.getQueryData(['sessions']);
+            queryClient.setQueryData(['sessions'], (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (Array.isArray(oldData)) {
+                    return oldData.map((session) => session.id === sessionId
+                        ? {
+                            ...session,
+                            breaks: [
+                                ...(session.breaks || []),
+                                {
+                                    ...breakData,
+                                    id: Math.random().toString(36).substr(2, 9),
+                                    session_id: sessionId,
+                                }
+                            ]
+                        }
+                        : session);
+                }
+                return oldData;
+            });
+            return { previousSessions };
+        },
+        onError: (err, variables, context) => {
+            if (context?.previousSessions) {
+                queryClient.setQueryData(['sessions'], context.previousSessions);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['sessions'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateUserSession = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: ({ sessionId, updates }) => {
+            return this.put(`/session/${sessionId}`, JSON.stringify(updates), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ sessionId, updates }) => {
+            await queryClient.cancelQueries({ queryKey: ['sessions'] });
+            const previousSessions = queryClient.getQueryData(['sessions']);
+            queryClient.setQueryData(['sessions'], (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (Array.isArray(oldData)) {
+                    return oldData.map((session) => session.id === sessionId ? { ...session, ...updates } : session);
+                }
+                return oldData;
+            });
+            return { previousSessions };
+        },
+        onError: (err, variables, context) => {
+            if (context?.previousSessions) {
+                queryClient.setQueryData(['sessions'], context.previousSessions);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['sessions'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateSessionBreak = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: ({ breakId, updates }) => {
+            return this.put(`/break/${breakId}`, JSON.stringify(updates), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ breakId, updates }) => {
+            await queryClient.cancelQueries({ queryKey: ['sessions'] });
+            const previousSessions = queryClient.getQueryData(['sessions']);
+            queryClient.setQueryData(['sessions'], (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (Array.isArray(oldData)) {
+                    return oldData.map((session) => ({
+                        ...session,
+                        breaks: session.breaks?.map(b => b.id === breakId ? { ...b, ...updates } : b)
+                    }));
+                }
+                return oldData;
+            });
+            return { previousSessions };
+        },
+        onError: (err, variables, context) => {
+            if (context?.previousSessions) {
+                queryClient.setQueryData(['sessions'], context.previousSessions);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['sessions'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useGetSessions = function (body) {
+    const queryClient = this.getQueryClient();
+    const result = useInfiniteQuery({
+        queryKey: ['sessions', this.companyId, body.amt ?? 50, body.query ?? ""],
+        initialPageParam: 0,
+        getNextPageParam: (lastPage, allPages) => {
+            if (lastPage.length < (body.amt ?? 50))
+                return undefined;
+            return allPages.flat().length; // next offset
+        },
+        queryFn: ({ pageParam = 0 }) => this.fetchSessions({ ...body, offset: pageParam }),
+    });
+    if (result.data) {
+        result.data.pages.forEach((data_page) => {
+            data_page.forEach((session) => {
+                queryClient.setQueryData(['session', session.id], session);
+            });
+        });
+    }
+    return result;
+};

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

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

package/dist/client/hooks/skills.js

@@ -0,0 +1,123 @@
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useCreateSkill = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ skillData }) => {
+            return this.post(`/company/${this.companyId}/skill`, JSON.stringify(skillData), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['company'] });
+            queryClient.invalidateQueries({ queryKey: ['skills'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useGetSkills = function (body, total, onProgress) {
+    return useQuery({
+        queryKey: ['skills', this.companyId, body.amt ?? 50, body.query ?? "", total ?? "all"],
+        queryFn: async () => {
+            if (typeof total !== "number") {
+                return this.fetchSkills({ ...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.fetchSkills({
+                ...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 skills = pages.flat();
+            return skills;
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateSkill = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ skillId, updates }) => {
+            return this.put(`/skill/${skillId}`, JSON.stringify(updates), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ skillId, updates }) => {
+            await queryClient.cancelQueries({ queryKey: ['skills'] });
+            await queryClient.cancelQueries({ queryKey: ['skill', skillId] });
+            const previousSkills = queryClient.getQueryData(['skills']);
+            const previousSkill = queryClient.getQueryData(['skill', skillId]);
+            queryClient.setQueryData(['skill', skillId], (oldData) => {
+                if (!oldData)
+                    return oldData;
+                return { ...oldData, ...updates };
+            });
+            queryClient.setQueriesData({ queryKey: ['skills'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.map((skill) => skill.id === skillId ? { ...skill, ...updates } : skill));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((skill) => skill.id === skillId ? { ...skill, ...updates } : skill);
+                }
+                return oldData;
+            });
+            return { previousSkills, previousSkill };
+        },
+        onError: (_err, variables, context) => {
+            const { skillId } = variables;
+            if (context?.previousSkills) {
+                queryClient.setQueryData(['skills'], context.previousSkills);
+            }
+            if (context?.previousSkill) {
+                queryClient.setQueryData(['skill', skillId], context.previousSkill);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { skillId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['skills'] });
+            queryClient.invalidateQueries({ queryKey: ['skill', skillId] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteSkill = function () {
+    const queryClient = this.getQueryClient();
+    return useMutation({
+        mutationFn: async ({ skillId }) => {
+            return this.delete(`/skill/${skillId}`);
+        },
+        onMutate: async ({ skillId }) => {
+            await queryClient.cancelQueries({ queryKey: ['skills'] });
+            const previousSkills = queryClient.getQueryData(['skills']);
+            queryClient.setQueriesData({ queryKey: ['skills'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.filter((skill) => skill.id !== skillId));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.filter((skill) => skill.id !== skillId);
+                }
+                return oldData;
+            });
+            return { previousSkills };
+        },
+        onError: (_err, variables, context) => {
+            if (context?.previousSkills) {
+                queryClient.setQueryData(['skills'], context.previousSkills);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['skills'] });
+        },
+    });
+};

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

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