@go-avro/avro-js 0.0.2-beta.57 → 0.0.2-beta.59

package/dist/client/QueryClient.d.ts

@@ -1,6 +1,6 @@
 import { InfiniteData, UseInfiniteQueryResult, useMutation, UseQueryResult } from '@tanstack/react-query';
 import { AuthManager } from '../auth/AuthManager';
-import { _Event, ApiInfo, Bill, Company, Job, LineItem, Route, ServiceMonth, Session, User } from '../types/api';
+import { _Event, ApiInfo, Bill, Company, Job, LineItem, Route, ServiceMonth, Session, User, UserCompanyAssociation } from '../types/api';
 import { Tokens } from '../types/auth';
 import { CancelToken, RetryStrategy } from '../types/client';
 import { StandardError } from '../types/error';
@@ -103,6 +103,15 @@ declare module '../client/QueryClient' {
             password: string;
             phone_number: string;
         }>>;
+        useCreateSessionBreak(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            sessionId: string;
+            breakData: {
+                start_time: string;
+                end_time?: string;
+            };
+        }>>;
         useUpdateEvent(): ReturnType<typeof useMutation<{
             msg: string;
         }, StandardError, {
@@ -147,6 +156,22 @@ declare module '../client/QueryClient' {
             })[];
             action: "billed" | "paid";
         }>>;
+        useUpdateUserCompany(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            company_id: string;
+            user_id: string;
+            data: Partial<UserCompanyAssociation>;
+        }>>;
+        useUpdateSessionBreak(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            breakId: string;
+            updates: {
+                start_time?: string;
+                end_time?: string;
+            };
+        }>>;
         useDeleteJob(): ReturnType<typeof useMutation<{
             msg: string;
         }, StandardError, {

package/dist/client/hooks/sessions.js

@@ -44,6 +44,49 @@ AvroQueryClient.prototype.useCreateUserSession = function () {
         },
     });
 };
+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({
@@ -75,3 +118,37 @@ AvroQueryClient.prototype.useUpdateUserSession = function () {
         },
     });
 };
+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/users.js

@@ -25,6 +25,50 @@ AvroQueryClient.prototype.useCreateSelf = function () {
         },
     });
 };
+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({

package/dist/types/api.d.ts

@@ -257,6 +257,12 @@ export interface Group {
     time_created: number;
     time_updated: number;
 }
+export declare const NotificationLevel: Readonly<{
+    IN_APP: 0;
+    EMAIL: 1;
+    SMS: 2;
+    PUSH: 3;
+}>;
 export interface UserCompanyAssociation {
     id: string;
     user: User;
@@ -267,7 +273,7 @@ export interface UserCompanyAssociation {
     time_updated: number | null;
     notification_setting: number[];
     share_email_company_wide: boolean;
-    notifications: number[];
+    notifications: Notification[];
     groups: string[];
 }
 export interface Email {

package/dist/types/api.js

@@ -1 +1,6 @@
-export {};
+export const NotificationLevel = Object.freeze({
+    IN_APP: 0,
+    EMAIL: 1,
+    SMS: 2,
+    PUSH: 3
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-avro/avro-js",
-  "version": "0.0.2-beta.57",
+  "version": "0.0.2-beta.59",
   "description": "JS client for Avro backend integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",