@go-avro/avro-js 0.0.2-beta.9 → 0.0.2-beta.90

package/dist/client/hooks/routes.js

@@ -0,0 +1,123 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.useGetRoutes = function (companyGuid, body, total, onProgress) {
+    return useQuery({
+        queryKey: ['routes', companyGuid, body.amt ?? 50, body.query ?? ""],
+        queryFn: async () => {
+            if (typeof total !== "number") {
+                return this.fetchRoutes(companyGuid, { ...body, offset: 0 });
+            }
+            onProgress?.(0);
+            const pageCount = body.amt ? Math.ceil(total / body.amt) : 0;
+            let completed = 0;
+            const promises = Array.from({ length: pageCount }, (_, i) => this.fetchRoutes(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 routes = pages.flat();
+            return routes;
+        },
+        enabled: Boolean(companyGuid) && companyGuid.length > 0,
+    });
+};
+AvroQueryClient.prototype.useGetRoute = function (routeId) {
+    const queryClient = useQueryClient();
+    return useQuery({
+        queryKey: ['route', routeId],
+        queryFn: () => this.get(`/route/${routeId}`),
+        enabled: Boolean(routeId) && routeId.length > 0,
+    });
+};
+AvroQueryClient.prototype.useUpdateRoute = function () {
+    const queryClient = useQueryClient();
+    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: ['route', routeId] });
+            queryClient.invalidateQueries({ queryKey: ['routes'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteRoute = function () {
+    const queryClient = useQueryClient();
+    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: ['route', routeId] });
+        },
+    });
+};

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

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

package/dist/client/hooks/sessions.js

@@ -0,0 +1,154 @@
+import { useMutation, useQuery, useQueryClient } 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 = useQueryClient();
+    return useMutation({
+        mutationFn: ({ companyId, sessionData }) => {
+            return this.post(`/company/${companyId}/session`, JSON.stringify(sessionData), undefined, {
+                "Content-Type": "application/json",
+            });
+        },
+        onMutate: async ({ companyId, 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: 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 = useQueryClient();
+    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 = useQueryClient();
+    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 = useQueryClient();
+    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'] });
+        },
+    });
+};

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

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

package/dist/client/hooks/teams.js

@@ -0,0 +1,117 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetTeams = function (companyGuid, body, total, onProgress) {
+    return useQuery({
+        queryKey: ['teams', companyGuid, body.amt ?? 50, body.query ?? ""],
+        queryFn: async () => {
+            if (typeof total !== "number") {
+                return this.fetchTeams(companyGuid, { ...body, offset: 0 });
+            }
+            onProgress?.(0);
+            const pageCount = body.amt ? Math.ceil(total / body.amt) : 0;
+            let completed = 0;
+            const promises = Array.from({ length: pageCount }, (_, i) => this.fetchTeams(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 teams = pages.flat();
+            return teams;
+        },
+        enabled: Boolean(companyGuid) && companyGuid.length > 0,
+    });
+};
+AvroQueryClient.prototype.useUpdateTeam = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ teamId, teamData }) => {
+            return this.put(`/team/${teamId}`, JSON.stringify(teamData), undefined, { "Content-Type": "application/json" });
+        },
+        onMutate: async ({ teamId, teamData }) => {
+            await queryClient.cancelQueries({ queryKey: ['teams'] });
+            await queryClient.cancelQueries({ queryKey: ['team', teamId] });
+            const previousTeams = queryClient.getQueryData(['teams']);
+            const previousTeam = queryClient.getQueryData(['team', teamId]);
+            queryClient.setQueryData(['team', teamId], (oldData) => {
+                if (!oldData)
+                    return oldData;
+                return { ...oldData, ...teamData };
+            });
+            queryClient.setQueriesData({ queryKey: ['teams'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.map((team) => team.id === teamId ? { ...team, ...teamData } : team));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.map((team) => team.id === teamId ? { ...team, ...teamData } : team);
+                }
+                return oldData;
+            });
+            return { previousTeams, previousTeam };
+        },
+        onError: (_err, variables, context) => {
+            const { teamId } = variables;
+            if (context?.previousTeams) {
+                queryClient.setQueryData(['teams'], context.previousTeams);
+            }
+            if (context?.previousTeam) {
+                queryClient.setQueryData(['team', teamId], context.previousTeam);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { teamId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['teams'] });
+            queryClient.invalidateQueries({ queryKey: ['team', teamId] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteTeam = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ teamId, }) => {
+            return this.delete(`/team/${teamId}`);
+        },
+        onMutate: async ({ teamId }) => {
+            await queryClient.cancelQueries({ queryKey: ['teams'] });
+            await queryClient.cancelQueries({ queryKey: ['team', teamId] });
+            const previousRoutes = queryClient.getQueryData(['teams']);
+            const previousRoute = queryClient.getQueryData(['team', teamId]);
+            queryClient.setQueryData(['team', teamId], undefined);
+            queryClient.setQueriesData({ queryKey: ['teams'] }, (oldData) => {
+                if (!oldData)
+                    return oldData;
+                if (oldData.pages) {
+                    const updatedPages = oldData.pages.map((page) => page.filter((team) => team.id !== teamId));
+                    return { ...oldData, pages: updatedPages };
+                }
+                if (Array.isArray(oldData)) {
+                    return oldData.filter((team) => team.id !== teamId);
+                }
+                return oldData;
+            });
+            return { previousRoutes, previousRoute };
+        },
+        onError: (_err, variables, context) => {
+            const { teamId } = variables;
+            if (context?.previousRoutes) {
+                queryClient.setQueryData(['teams'], context.previousRoutes);
+            }
+            if (context?.previousRoute) {
+                queryClient.setQueryData(['team', teamId], context.previousRoute);
+            }
+        },
+        onSettled: (_data, _error, variables) => {
+            const { teamId } = variables;
+            queryClient.invalidateQueries({ queryKey: ['teams'] });
+            queryClient.invalidateQueries({ queryKey: ['team', teamId] });
+        },
+    });
+};

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

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

package/dist/client/hooks/users.js

@@ -0,0 +1,104 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetUser = function (userId) {
+    return useQuery({
+        queryKey: ['user', userId],
+        queryFn: () => this.get(`/user/${userId}`),
+        enabled: Boolean(userId),
+    });
+};
+AvroQueryClient.prototype.useSearchUsers = function (searchUsername) {
+    return useQuery({
+        queryKey: ['user', 'search', searchUsername],
+        queryFn: () => {
+            if (!searchUsername)
+                return Promise.resolve([]);
+            return this.get(`/user/search/${searchUsername}`);
+        },
+        enabled: Boolean(searchUsername),
+    });
+};
+AvroQueryClient.prototype.useGetSelf = function () {
+    return useQuery({
+        queryKey: ['user'],
+        queryFn: () => this.get(`/user`),
+        enabled: Boolean(this),
+    });
+};
+AvroQueryClient.prototype.useCreateSelf = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (data) => {
+            return this.post('/user', JSON.stringify(data), undefined, { "Content-Type": "application/json" });
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['user'] });
+        },
+    });
+};
+AvroQueryClient.prototype.useUpdateUserCompany = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ company_id, user_id, data }) => {
+            return this.put(`/company/${company_id}/user/${user_id}`, JSON.stringify(data), undefined, { "Content-Type": "application/json" });
+        },
+        // Optimistically update the user data and company data in the cache
+        onMutate: async (data) => {
+            await queryClient.cancelQueries({ queryKey: ['user'] });
+            await queryClient.cancelQueries({ queryKey: ['company', data.company_id] });
+            const previousUser = queryClient.getQueryData(['user']);
+            const previousCompany = queryClient.getQueryData(['company', data.company_id]);
+            if (previousUser) {
+                let oldUserCompany = previousUser.companies?.find(c => c.company === data.company_id);
+                if (oldUserCompany) {
+                    oldUserCompany = { ...oldUserCompany, ...data.data };
+                    const newCompanies = previousUser.companies?.map(c => c.company === data.company_id ? oldUserCompany : c) ?? [];
+                    queryClient.setQueryData(['user'], { ...previousUser, companies: newCompanies });
+                }
+            }
+            if (previousCompany) {
+                let oldCompanyUser = previousCompany.users?.find((u) => u.user.id === data.user_id);
+                if (oldCompanyUser) {
+                    oldCompanyUser = { ...oldCompanyUser, ...data.data };
+                    const newUsers = previousCompany.users?.map((u) => u.user.id === data.user_id ? oldCompanyUser : u) ?? [];
+                    queryClient.setQueryData(['company', data.company_id], { ...previousCompany, users: newUsers });
+                }
+            }
+            return { previousUser, previousCompany };
+        },
+        onError: (err, _, context) => {
+            if (context?.previousUser) {
+                queryClient.setQueryData(['user'], context.previousUser);
+            }
+            if (context?.previousCompany) {
+                queryClient.setQueryData(['company'], context.previousCompany);
+            }
+        },
+        onSettled: (data, error, variables) => {
+            queryClient.invalidateQueries({ queryKey: ['user'] });
+            queryClient.invalidateQueries({ queryKey: ['company', variables.company_id] });
+        },
+    });
+};
+AvroQueryClient.prototype.useDeleteSelf = function () {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async () => {
+            return this.delete(`/user`);
+        },
+        onMutate: async () => {
+            await queryClient.cancelQueries({ queryKey: ['user'] });
+            const previousUser = queryClient.getQueryData(['user']);
+            queryClient.removeQueries({ queryKey: ['user'] });
+            return { previousUser };
+        },
+        onError: (err, _, context) => {
+            if (context?.previousUser) {
+                queryClient.setQueryData(['user'], context.previousUser);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: ['user'] });
+        },
+    });
+};

package/dist/index.d.ts

@@ -1,6 +1,25 @@
 export { AvroQueryClientConfig, AvroQueryClient } from './client/QueryClient';
 export { AuthManager } from './auth/AuthManager';
 export { MemoryStorage, LocalStorage } from './auth/storage';
+import './client/core/xhr';
+import './client/core/fetch';
+import './client/core/utils';
+import './client/hooks/root';
+import './client/hooks/jobs';
+import './client/hooks/routes';
+import './client/hooks/events';
+import './client/hooks/months';
+import './client/hooks/bills';
+import './client/hooks/companies';
+import './client/hooks/users';
+import './client/hooks/sessions';
+import './client/hooks/chats';
+import './client/hooks/messages';
+import './client/hooks/plans';
+import './client/hooks/analytics';
+import './client/hooks/avro';
+import './client/hooks/teams';
 export * from './types/api';
+export * from './types/auth';
 export * from './types/error';
 export * from './types/client';

package/dist/index.js

@@ -1,6 +1,25 @@
 export { AvroQueryClient } from './client/QueryClient';
 export { AuthManager } from './auth/AuthManager';
 export { MemoryStorage, LocalStorage } from './auth/storage';
+import './client/core/xhr';
+import './client/core/fetch';
+import './client/core/utils';
+import './client/hooks/root';
+import './client/hooks/jobs';
+import './client/hooks/routes';
+import './client/hooks/events';
+import './client/hooks/months';
+import './client/hooks/bills';
+import './client/hooks/companies';
+import './client/hooks/users';
+import './client/hooks/sessions';
+import './client/hooks/chats';
+import './client/hooks/messages';
+import './client/hooks/plans';
+import './client/hooks/analytics';
+import './client/hooks/avro';
+import './client/hooks/teams';
 export * from './types/api';
+export * from './types/auth';
 export * from './types/error';
 export * from './types/client';