@go-avro/avro-js 0.0.19 → 0.0.21

package/dist/client/AvroQueryClientProvider.d.ts

@@ -11,4 +11,15 @@ export interface AvroQueryClientProviderProps {
 }
 export declare const AvroQueryClientProvider: ({ baseUrl, authManager, configOverrides, children, }: AvroQueryClientProviderProps) => React.JSX.Element;
 export declare const useAvroQueryClient: () => AvroQueryClient;
+/**
+ * Subscribe to a raw socket event for UI-only side-effects (toasts,
+ * alerts, etc.) without managing on/off yourself.  Query invalidation
+ * is already handled automatically — this is only for presentation.
+ *
+ * @example
+ * useSocketEvent<{ msg: string }>("scheduling_error", (data) => {
+ *   toast({ title: "Error", description: data.msg });
+ * });
+ */
+export declare const useSocketEvent: <T = unknown>(eventName: string, callback: (data: T) => void) => void;
 export default AvroQueryClientProvider;

package/dist/client/AvroQueryClientProvider.js

@@ -1,6 +1,21 @@
-import React, { createContext, useContext, useMemo, useEffect } from "react";
+import React, { createContext, useContext, useMemo, useEffect, useRef, useCallback } from "react";
+import { useQueryClient } from "@tanstack/react-query";
 import { AvroQueryClient } from "./QueryClient";
 const AvroQueryClientContext = createContext(null);
+/**
+ * Inner component that has access to the tanstack QueryClient via
+ * useQueryClient() and wires up socket → query invalidation.
+ */
+const SocketInvalidationBridge = ({ client }) => {
+    const queryClient = useQueryClient();
+    useEffect(() => {
+        client.setupSocketInvalidation(queryClient);
+        return () => {
+            client.teardownSocketInvalidation();
+        };
+    }, [client, queryClient]);
+    return null;
+};
 export const AvroQueryClientProvider = ({ baseUrl, authManager, configOverrides, children, }) => {
     const client = useMemo(() => {
         const cfg = {
@@ -13,6 +28,7 @@ export const AvroQueryClientProvider = ({ baseUrl, authManager, configOverrides,
     useEffect(() => {
         return () => {
             try {
+                client.teardownSocketInvalidation();
                 client.socket?.disconnect();
             }
             catch (e) {
@@ -20,7 +36,9 @@ export const AvroQueryClientProvider = ({ baseUrl, authManager, configOverrides,
             }
         };
     }, [client]);
-    return (React.createElement(AvroQueryClientContext.Provider, { value: client }, children));
+    return (React.createElement(AvroQueryClientContext.Provider, { value: client },
+        React.createElement(SocketInvalidationBridge, { client: client }),
+        children));
 };
 export const useAvroQueryClient = () => {
     const ctx = useContext(AvroQueryClientContext);
@@ -29,4 +47,26 @@ export const useAvroQueryClient = () => {
     }
     return ctx;
 };
+/**
+ * Subscribe to a raw socket event for UI-only side-effects (toasts,
+ * alerts, etc.) without managing on/off yourself.  Query invalidation
+ * is already handled automatically — this is only for presentation.
+ *
+ * @example
+ * useSocketEvent<{ msg: string }>("scheduling_error", (data) => {
+ *   toast({ title: "Error", description: data.msg });
+ * });
+ */
+export const useSocketEvent = (eventName, callback) => {
+    const client = useAvroQueryClient();
+    const callbackRef = useRef(callback);
+    callbackRef.current = callback;
+    const stableHandler = useCallback((data) => callbackRef.current(data), []);
+    useEffect(() => {
+        client.on(eventName, stableHandler);
+        return () => {
+            client.off(eventName, stableHandler);
+        };
+    }, [client, eventName, stableHandler]);
+};
 export default AvroQueryClientProvider;

package/dist/client/QueryClient.d.ts

@@ -166,7 +166,7 @@ declare module '../client/QueryClient' {
         useGetTimecard(timecardId?: string, enabled?: boolean): UseQueryResult<Timecard, StandardError>;
         useGetAvro(): UseQueryResult<Avro, StandardError>;
         useSearchUsers(searchUsername: string): UseQueryResult<User[], StandardError>;
-        useAcceptProposal(proposal_id: string): ReturnType<typeof useMutation<{
+        useReviewProposal(proposal_id: string): ReturnType<typeof useMutation<{
             msg: string;
             bill_id?: string;
         }, StandardError, {
@@ -513,10 +513,23 @@ export declare class AvroQueryClient {
     companyId: string | undefined;
     company: Company | undefined;
     private authStateListeners;
+    private _queryClient;
+    private _socketInvalidationCleanup;
     constructor(config: AvroQueryClientConfig);
     emit(eventName: string, data: unknown): void;
     on<T>(eventName: string, callback: (data: T) => void): void;
     off(eventName: string, callback?: Function): void;
+    /**
+     * Wire up automatic query invalidation for socket events.
+     * Called once from AvroQueryClientProvider when the tanstack
+     * QueryClient is available.  Also handles auto-joining the
+     * company room on connect so consumer apps don't have to.
+     */
+    setupSocketInvalidation(queryClient: QueryClient): void;
+    /**
+     * Remove all invalidation listeners. Called on provider unmount.
+     */
+    teardownSocketInvalidation(): void;
     get<T>({ path, cancelToken, headers, progressUpdateCallback }: {
         path: string;
         cancelToken?: CancelToken;

package/dist/client/QueryClient.js

@@ -3,12 +3,89 @@ import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { LoginResponse } from '../types/api';
 import { AuthState } from '../types/auth';
 import { StandardError } from '../types/error';
+/**
+ * Maps socket event names to the query keys that should be invalidated
+ * when that event is received. Chat events are excluded — they carry
+ * their own data and are handled separately by consumer apps.
+ */
+const SOCKET_INVALIDATION_MAP = {
+    // Company
+    create_company: [['companies']],
+    update_company: [['companies']],
+    delete_company: [['companies']],
+    // Users
+    user_updated: [['users']],
+    update_users: [['users']],
+    // Jobs
+    create_job: [['jobs']],
+    update_job: [['jobs']],
+    update_jobs: [['jobs']],
+    delete_job: [['jobs']],
+    delete_jobs: [['jobs']],
+    // Routes
+    create_route: [['routes']],
+    update_route: [['routes']],
+    delete_route: [['routes']],
+    // Events
+    create_event: [['events']],
+    update_event: [['events']],
+    update_events: [['events']],
+    delete_event: [['events']],
+    // Teams
+    create_team: [['teams']],
+    update_team: [['teams']],
+    update_teams: [['teams']],
+    delete_team: [['teams']],
+    // Bills
+    create_bill: [['bills']],
+    update_bills: [['bills']],
+    delete_bill: [['bills']],
+    // Sessions
+    create_session: [['sessions']],
+    update_session: [['sessions']],
+    // Catalog
+    create_catalog_item: [['catalog_items']],
+    update_catalog_item: [['catalog_items']],
+    delete_catalog_item: [['catalog_items']],
+    // Groups
+    create_group: [['groups']],
+    update_group: [['groups']],
+    delete_group: [['groups']],
+    // Labels
+    create_label: [['labels']],
+    update_label: [['labels']],
+    delete_label: [['labels']],
+    // Skills
+    create_skill: [['skills']],
+    update_skill: [['skills']],
+    delete_skill: [['skills']],
+    // Proposals
+    create_proposal: [['proposals']],
+    update_proposal: [['proposals']],
+    delete_proposal: [['proposals']],
+    // Service Months
+    create_month: [['months']],
+    update_months: [['months']],
+    delete_months: [['months']],
+    // Tasks
+    create_task: [['jobs']],
+    update_task: [['jobs']],
+    delete_task: [['jobs']],
+    // Scheduling
+    schedule_complete: [['routes'], ['jobs']],
+    // Location
+    location_update: [['teams']],
+    // Prepayments
+    update_prepayments: [['prepayments']],
+};
 export class AvroQueryClient {
     constructor(config) {
         this._authState = AuthState.UNKNOWN;
         this.companyId = undefined;
         this.company = undefined;
         this.authStateListeners = [];
+        this._queryClient = null;
+        this._socketInvalidationCleanup = null;
         this.config = {
             baseUrl: config.baseUrl,
             authManager: config.authManager,
@@ -70,6 +147,58 @@ export class AvroQueryClient {
     off(eventName, callback) {
         this.socket?.off(eventName, callback);
     }
+    /**
+     * Wire up automatic query invalidation for socket events.
+     * Called once from AvroQueryClientProvider when the tanstack
+     * QueryClient is available.  Also handles auto-joining the
+     * company room on connect so consumer apps don't have to.
+     */
+    setupSocketInvalidation(queryClient) {
+        // Prevent double-setup
+        if (this._queryClient)
+            return;
+        this._queryClient = queryClient;
+        const handlers = [];
+        // Register invalidation listeners for every mapped event
+        for (const [event, queryKeys] of Object.entries(SOCKET_INVALIDATION_MAP)) {
+            const handler = () => {
+                for (const key of queryKeys) {
+                    queryClient.invalidateQueries({ queryKey: key });
+                }
+            };
+            this.socket.on(event, handler);
+            handlers.push({ event, handler });
+        }
+        // Auto join/leave company room
+        const joinCompanyRoom = () => {
+            if (this.companyId) {
+                this.socket.emit('join_company', { company_id: this.companyId });
+            }
+        };
+        this.socket.on('connect', joinCompanyRoom);
+        handlers.push({ event: 'connect', handler: joinCompanyRoom });
+        // If already connected, join immediately
+        if (this.socket.connected && this.companyId) {
+            joinCompanyRoom();
+        }
+        this._socketInvalidationCleanup = () => {
+            for (const { event, handler } of handlers) {
+                this.socket.off(event, handler);
+            }
+            // Leave company room on teardown
+            if (this.socket.connected && this.companyId) {
+                this.socket.emit('leave_company', { company_id: this.companyId });
+            }
+            this._queryClient = null;
+        };
+    }
+    /**
+     * Remove all invalidation listeners. Called on provider unmount.
+     */
+    teardownSocketInvalidation() {
+        this._socketInvalidationCleanup?.();
+        this._socketInvalidationCleanup = null;
+    }
     get({ path, cancelToken, headers, progressUpdateCallback }) {
         return this._xhr('GET', path, null, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
     }

package/dist/client/hooks/bills.js

@@ -22,7 +22,7 @@ AvroQueryClient.prototype.useGetBills = function (body) {
     if (result.data) {
         result.data.pages.forEach((data_page) => {
             data_page.forEach((bill) => {
-                queryClient.setQueryData(['bill', bill.id], bill);
+                queryClient.setQueryData(['bills', bill.id], bill);
             });
         });
     }
@@ -30,7 +30,7 @@ AvroQueryClient.prototype.useGetBills = function (body) {
 };
 AvroQueryClient.prototype.useGetBill = function (billId) {
     return useQuery({
-        queryKey: ['bill', billId],
+        queryKey: ['bills', billId],
         queryFn: () => this.get({ path: `/bill/${billId}` }),
         enabled: Boolean(billId),
     });
@@ -72,7 +72,7 @@ AvroQueryClient.prototype.useCreateBill = function () {
             queryClient.invalidateQueries({ queryKey: ['bills', this.companyId] });
             queryClient.invalidateQueries({ queryKey: ['events', this.companyId] });
             queryClient.invalidateQueries({ queryKey: ['months', this.companyId] });
-            queryClient.invalidateQueries({ queryKey: ['company'] });
+            queryClient.invalidateQueries({ queryKey: ['companies'] });
         },
     });
 };
@@ -90,10 +90,10 @@ AvroQueryClient.prototype.useUpdateBill = function () {
         },
         onMutate: async ({ billId, updates }) => {
             await queryClient.cancelQueries({ queryKey: ['bills'] });
-            await queryClient.cancelQueries({ queryKey: ['bill', billId] });
+            await queryClient.cancelQueries({ queryKey: ['bills', billId] });
             const previousBills = queryClient.getQueryData(['bills']);
-            const previousBill = queryClient.getQueryData(['bill', billId]);
-            queryClient.setQueryData(['bill', billId], (oldData) => oldData ? { ...oldData, ...updates } : undefined);
+            const previousBill = queryClient.getQueryData(['bills', billId]);
+            queryClient.setQueryData(['bills', billId], (oldData) => oldData ? { ...oldData, ...updates } : undefined);
             queryClient.setQueriesData({ queryKey: ['bills'] }, (oldData) => {
                 if (!oldData)
                     return oldData;
@@ -116,13 +116,12 @@ AvroQueryClient.prototype.useUpdateBill = function () {
                 queryClient.setQueryData(['bills'], context.previousBills);
             }
             if (context?.previousBill) {
-                queryClient.setQueryData(['bill', billId], context.previousBill);
+                queryClient.setQueryData(['bills', billId], context.previousBill);
             }
         },
         onSettled: (data, error, variables) => {
             const { billId } = variables;
             queryClient.invalidateQueries({ queryKey: ['bills'] });
-            queryClient.invalidateQueries({ queryKey: ['bill', billId] });
         },
     });
 };
@@ -159,19 +158,19 @@ AvroQueryClient.prototype.useSyncBillToIntuit = function () {
             });
         },
         onMutate: async ({ billId }) => {
-            await queryClient.cancelQueries({ queryKey: ['bill', billId] });
-            const previousBill = queryClient.getQueryData(['bill', billId]);
+            await queryClient.cancelQueries({ queryKey: ['bills', billId] });
+            const previousBill = queryClient.getQueryData(['bills', billId]);
             return { previousBill };
         },
         onError: (_err, variables, context) => {
             const { billId } = variables;
             if (context?.previousBill) {
-                queryClient.setQueryData(['bill', billId], context.previousBill);
+                queryClient.setQueryData(['bills', billId], context.previousBill);
             }
         },
         onSettled: (_data, _error, variables) => {
             const { billId } = variables;
-            queryClient.invalidateQueries({ queryKey: ['bill', billId] });
+            queryClient.invalidateQueries({ queryKey: ['bills', billId] });
         },
     });
 };
@@ -185,7 +184,7 @@ AvroQueryClient.prototype.useImportBillsFromIntuit = function () {
         },
         onSettled: () => {
             queryClient.invalidateQueries({ queryKey: ['bills', this.companyId] });
-            queryClient.invalidateQueries({ queryKey: ['company', 'current'] });
+            queryClient.invalidateQueries({ queryKey: ['companies', 'current'] });
         },
     });
 };

package/dist/client/hooks/catalog_items.js

@@ -41,10 +41,10 @@ AvroQueryClient.prototype.useUpdateCatalogItem = function () {
         },
         onMutate: async ({ catalogItemId, data }) => {
             await queryClient.cancelQueries({ queryKey: ['catalog_items'] });
-            await queryClient.cancelQueries({ queryKey: ['catalog_item', catalogItemId] });
+            await queryClient.cancelQueries({ queryKey: ['catalog_items', catalogItemId] });
             const previousItems = queryClient.getQueryData(['catalog_items']);
-            const previousItem = queryClient.getQueryData(['catalog_item', catalogItemId]);
-            queryClient.setQueryData(['catalog_item', catalogItemId], (oldData) => oldData ? { ...oldData, ...data } : undefined);
+            const previousItem = queryClient.getQueryData(['catalog_items', catalogItemId]);
+            queryClient.setQueryData(['catalog_items', catalogItemId], (oldData) => oldData ? { ...oldData, ...data } : undefined);
             queryClient.setQueriesData({ queryKey: ['catalog_items'] }, (oldData) => {
                 if (!oldData)
                     return oldData;
@@ -67,19 +67,18 @@ AvroQueryClient.prototype.useUpdateCatalogItem = function () {
                 queryClient.setQueryData(['catalog_items'], context.previousItems);
             }
             if (context?.previousItem) {
-                queryClient.setQueryData(['catalog_item', catalogItemId], context.previousItem);
+                queryClient.setQueryData(['catalog_items', catalogItemId], context.previousItem);
             }
         },
         onSettled: (_data, _error, variables) => {
             const { catalogItemId } = variables;
             queryClient.invalidateQueries({ queryKey: ['catalog_items'] });
-            queryClient.invalidateQueries({ queryKey: ['catalog_item', catalogItemId] });
         },
     });
 };
 AvroQueryClient.prototype.useGetCatalogItem = function (catalogItemId) {
     return useQuery({
-        queryKey: ['catalog_item', catalogItemId],
+        queryKey: ['catalog_items', catalogItemId],
         queryFn: () => this.get({ path: `/catalog_item/${catalogItemId}` }),
         enabled: Boolean(catalogItemId),
     });

package/dist/client/hooks/chats.js

@@ -22,7 +22,7 @@ AvroQueryClient.prototype.useGetChats = function (body) {
     if (result.data) {
         result.data.pages.forEach((data_page) => {
             data_page.forEach((chat) => {
-                queryClient.setQueryData(['chat', chat.id], chat);
+                queryClient.setQueryData(['chats', chat.id], chat);
             });
         });
     }
@@ -30,7 +30,7 @@ AvroQueryClient.prototype.useGetChats = function (body) {
 };
 AvroQueryClient.prototype.useGetChat = function (chatId) {
     return useQuery({
-        queryKey: ['chat', chatId],
+        queryKey: ['chats', chatId],
         queryFn: () => this.get({ path: `/chat/${chatId}` }),
         enabled: Boolean(chatId),
     });

package/dist/client/hooks/companies.js

@@ -19,14 +19,14 @@ AvroQueryClient.prototype.useGetCompanies = function (options = {}) {
 };
 AvroQueryClient.prototype.useGetCompany = function (companyId) {
     return useQuery({
-        queryKey: ['company', companyId],
+        queryKey: ['companies', companyId],
         queryFn: () => this.get({ path: `/company/${companyId}` }),
         enabled: Boolean(companyId),
     });
 };
 AvroQueryClient.prototype.useGetCurrentCompany = function () {
     return useQuery({
-        queryKey: ['company', 'current'],
+        queryKey: ['companies', 'current'],
         queryFn: async () => {
             if (!this.companyId) {
                 this.companyId = await this.config.authManager.getCompanyId();
@@ -72,11 +72,11 @@ AvroQueryClient.prototype.useUpdateCompany = function () {
             });
         },
         onMutate: async ({ companyId, companyData }) => {
-            await queryClient.cancelQueries({ queryKey: ['company', companyId] });
+            await queryClient.cancelQueries({ queryKey: ['companies', companyId] });
             await queryClient.cancelQueries({ queryKey: ['/company/list'] });
-            const previousCompany = queryClient.getQueryData(['company', companyId]);
+            const previousCompany = queryClient.getQueryData(['companies', companyId]);
             const previousCompanyList = queryClient.getQueryData(['/company/list']);
-            queryClient.setQueryData(['company', companyId], (oldData) => oldData ? { ...oldData, ...companyData } : undefined);
+            queryClient.setQueryData(['companies', companyId], (oldData) => oldData ? { ...oldData, ...companyData } : undefined);
             queryClient.setQueryData(['/company/list'], (oldList) => {
                 if (!oldList)
                     return oldList;
@@ -87,7 +87,7 @@ AvroQueryClient.prototype.useUpdateCompany = function () {
         onError: (_err, variables, context) => {
             const { companyId } = variables;
             if (context?.previousCompany) {
-                queryClient.setQueryData(['company', companyId], context.previousCompany);
+                queryClient.setQueryData(['companies', companyId], context.previousCompany);
             }
             if (context?.previousCompanyList) {
                 queryClient.setQueryData(['/company/list'], context.previousCompanyList);
@@ -95,7 +95,7 @@ AvroQueryClient.prototype.useUpdateCompany = function () {
         },
         onSettled: (_data, _error, variables) => {
             const { companyId } = variables;
-            queryClient.invalidateQueries({ queryKey: ['company', companyId] });
+            queryClient.invalidateQueries({ queryKey: ['companies', companyId] });
             queryClient.invalidateQueries({ queryKey: ['/company/list'] });
         },
     });
@@ -114,9 +114,9 @@ AvroQueryClient.prototype.useCreateUserCompany = function () {
             });
         },
         onMutate: async ({ user_id }) => {
-            await queryClient.cancelQueries({ queryKey: ['company', this.companyId] });
-            const previousCompany = queryClient.getQueryData(['company', this.companyId]);
-            queryClient.setQueryData(['company', this.companyId], (oldData) => {
+            await queryClient.cancelQueries({ queryKey: ['companies', this.companyId] });
+            const previousCompany = queryClient.getQueryData(['companies', this.companyId]);
+            queryClient.setQueryData(['companies', this.companyId], (oldData) => {
                 if (!oldData)
                     return oldData;
                 return {
@@ -128,13 +128,13 @@ AvroQueryClient.prototype.useCreateUserCompany = function () {
         },
         onError: (err, variables, context) => {
             if (context?.previousCompany) {
-                queryClient.setQueryData(['company', this.companyId], context.previousCompany);
+                queryClient.setQueryData(['companies', this.companyId], context.previousCompany);
             }
         },
         onSettled: (_data, _error, variables) => {
-            queryClient.invalidateQueries({ queryKey: ['company', this.companyId] });
+            queryClient.invalidateQueries({ queryKey: ['companies', this.companyId] });
             queryClient.invalidateQueries({ queryKey: ['/company/list'] });
-            queryClient.invalidateQueries({ queryKey: ['company', 'current'] });
+            queryClient.invalidateQueries({ queryKey: ['companies', 'current'] });
         },
     });
 };
@@ -147,9 +147,9 @@ AvroQueryClient.prototype.useRemoveUserCompany = function () {
             });
         },
         onMutate: async ({ userId }) => {
-            await queryClient.cancelQueries({ queryKey: ['company', this.companyId] });
-            const previousCompany = queryClient.getQueryData(['company', this.companyId]);
-            queryClient.setQueryData(['company', this.companyId], (oldData) => {
+            await queryClient.cancelQueries({ queryKey: ['companies', this.companyId] });
+            const previousCompany = queryClient.getQueryData(['companies', this.companyId]);
+            queryClient.setQueryData(['companies', this.companyId], (oldData) => {
                 if (!oldData)
                     return oldData;
                 return {
@@ -161,11 +161,11 @@ AvroQueryClient.prototype.useRemoveUserCompany = function () {
         },
         onError: (err, variables, context) => {
             if (context?.previousCompany) {
-                queryClient.setQueryData(['company', this.companyId], context.previousCompany);
+                queryClient.setQueryData(['companies', this.companyId], context.previousCompany);
             }
         },
         onSettled: (_data, _error, variables) => {
-            queryClient.invalidateQueries({ queryKey: ['company', this.companyId] });
+            queryClient.invalidateQueries({ queryKey: ['companies', this.companyId] });
         },
     });
 };
@@ -179,7 +179,7 @@ AvroQueryClient.prototype.useDeleteCompany = function () {
         },
         onMutate: async ({ companyId }) => {
             await queryClient.cancelQueries({ queryKey: ['/company/list'] });
-            await queryClient.cancelQueries({ queryKey: ['company', companyId] });
+            await queryClient.cancelQueries({ queryKey: ['companies', companyId] });
             const previousCompanyList = queryClient.getQueryData(['/company/list']);
             queryClient.setQueryData(['/company/list'], (oldList) => {
                 if (!oldList)
@@ -195,7 +195,7 @@ AvroQueryClient.prototype.useDeleteCompany = function () {
         },
         onSettled: (_data, _error, companyId) => {
             queryClient.invalidateQueries({ queryKey: ['/company/list'] });
-            queryClient.invalidateQueries({ queryKey: ['company', companyId] });
+            queryClient.invalidateQueries({ queryKey: ['companies', companyId] });
         },
     });
 };