@go-avro/avro-js 0.0.2-beta.134 → 0.0.2-beta.136

package/dist/auth/storage.js

@@ -17,8 +17,11 @@ export class LocalStorage {
         this.key = 'cache_data';
     }
     async get(key) {
-        const item = localStorage.getItem(this.key);
-        return item ? JSON.parse(item) : null;
+        const item = JSON.parse(localStorage.getItem(this.key) ?? 'null');
+        if (typeof item !== 'object' || item === null) {
+            return null;
+        }
+        return item ? key ? item[key] ?? null : item : null;
     }
     async set(data) {
         const current = await this.get() || {};

package/dist/client/AvroQueryClientProvider.d.ts

@@ -0,0 +1,14 @@
+import React, { ReactNode } from "react";
+import { QueryClient } from "@tanstack/react-query";
+import { AvroQueryClient, AvroQueryClientConfig } from "./QueryClient";
+import { AuthManager } from "../auth/AuthManager";
+export interface AvroQueryClientProviderProps {
+    baseUrl: string;
+    authManager: AuthManager;
+    queryClient?: QueryClient;
+    configOverrides?: Partial<AvroQueryClientConfig>;
+    children: ReactNode;
+}
+export declare const AvroQueryClientProvider: ({ baseUrl, authManager, configOverrides, children, }: AvroQueryClientProviderProps) => React.JSX.Element;
+export declare const useAvroQueryClient: () => AvroQueryClient;
+export default AvroQueryClientProvider;

package/dist/client/AvroQueryClientProvider.js

@@ -0,0 +1,32 @@
+import React, { createContext, useContext, useMemo, useEffect } from "react";
+import { AvroQueryClient } from "./QueryClient";
+const AvroQueryClientContext = createContext(null);
+export const AvroQueryClientProvider = ({ baseUrl, authManager, configOverrides, children, }) => {
+    const client = useMemo(() => {
+        const cfg = {
+            baseUrl,
+            authManager,
+            ...(configOverrides || {}),
+        };
+        return new AvroQueryClient(cfg);
+    }, [baseUrl, authManager, configOverrides]);
+    useEffect(() => {
+        return () => {
+            try {
+                client.socket?.disconnect();
+            }
+            catch (e) {
+                // ignore
+            }
+        };
+    }, [client]);
+    return (React.createElement(AvroQueryClientContext.Provider, { value: client }, children));
+};
+export const useAvroQueryClient = () => {
+    const ctx = useContext(AvroQueryClientContext);
+    if (!ctx) {
+        throw new Error("useAvroQueryClient must be used within <AvroQueryClientProvider>");
+    }
+    return ctx;
+};
+export default AvroQueryClientProvider;

package/dist/client/QueryClient.d.ts

@@ -1,7 +1,7 @@
 import { Socket } from 'socket.io-client';
 import { InfiniteData, QueryClient, UseInfiniteQueryResult, useMutation, UseQueryResult } from '@tanstack/react-query';
 import { AuthManager } from '../auth/AuthManager';
-import { _Event, ApiInfo, Avro, Bill, Break, Chat, Company, FinancialInsightData, Job, EventInsightData, LoginResponse, Message, Plan, Route, ServiceMonth, Session, Team, User, UserCompanyAssociation, Skill } from '../types/api';
+import { _Event, ApiInfo, Avro, Bill, Break, Chat, Company, FinancialInsightData, Job, EventInsightData, LoginResponse, Message, Plan, Route, ServiceMonth, Session, Team, User, UserCompanyAssociation, Skill, Group } from '../types/api';
 import { Tokens } from '../types/auth';
 import { CancelToken, RetryStrategy } from '../types/client';
 import { StandardError } from '../types/error';
@@ -9,7 +9,6 @@ import { CacheData } from '../types/cache';
 export interface AvroQueryClientConfig {
     baseUrl: string;
     authManager: AuthManager;
-    queryClient: QueryClient;
     maxRetries?: number;
     retryStrategy?: RetryStrategy;
     timeout?: number;
@@ -87,6 +86,13 @@ declare module '../client/QueryClient' {
             query?: string;
             paid?: boolean;
         }): UseInfiniteQueryResult<InfiniteData<Bill[], unknown>, StandardError>;
+        useGetGroups(body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            offset?: number;
+        }, total: number, onProgress?: (fraction: number) => void): UseQueryResult<Group[], StandardError>;
         useGetPlans(code: string): UseQueryResult<Plan[], StandardError>;
         useGetCompanies(options?: {}): UseQueryResult<Company[], StandardError>;
         useGetAnalytics(): UseQueryResult<any, StandardError>;
@@ -109,6 +115,11 @@ declare module '../client/QueryClient' {
         useGetUserSessions(): UseQueryResult<Session[], StandardError>;
         useGetAvro(): UseQueryResult<Avro, StandardError>;
         useSearchUsers(searchUsername: string): UseQueryResult<User[], StandardError>;
+        useCreateGroup(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            groupData: Partial<Group>;
+        }>>;
         useCreateSkill(): ReturnType<typeof useMutation<{
             id: string;
         }, StandardError, {
@@ -186,6 +197,12 @@ declare module '../client/QueryClient' {
             sessionId: string;
             updates: Partial<Session>;
         }>>;
+        useUpdateGroup(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            groupId: string;
+            groupData: Partial<Group>;
+        }>>;
         useUpdateJob(): ReturnType<typeof useMutation<{
             msg: string;
         }, StandardError, {
@@ -258,6 +275,11 @@ declare module '../client/QueryClient' {
         }, StandardError, {
             userId: string;
         }>>;
+        useDeleteGroup(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            groupId: string;
+        }>>;
         useDeleteEvent(): ReturnType<typeof useMutation<{
             msg: string;
         }, StandardError, {
@@ -414,6 +436,13 @@ export declare class AvroQueryClient {
         query?: string;
         offset?: number;
     }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchGroups(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
     fetchSkills(body?: {
         amt?: number;
         known_ids?: string[];

package/dist/client/QueryClient.js

@@ -1,5 +1,5 @@
 import io from 'socket.io-client';
-import { useMutation } from '@tanstack/react-query';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { LoginResponse } from '../types/api';
 import { StandardError } from '../types/error';
 export class AvroQueryClient {
@@ -12,7 +12,6 @@ export class AvroQueryClient {
         this.config = {
             baseUrl: config.baseUrl,
             authManager: config.authManager,
-            queryClient: config.queryClient,
             maxRetries: config.maxRetries ?? 3,
             retryStrategy: config.retryStrategy ?? 'fixed',
             timeout: config.timeout ?? 0,
@@ -233,7 +232,7 @@ export class AvroQueryClient {
         return this.config.authManager.isAuthenticated();
     }
     getQueryClient() {
-        return this.config.queryClient;
+        return useQueryClient();
     }
     useLogout() {
         const queryClient = this.getQueryClient();
@@ -409,6 +408,25 @@ export class AvroQueryClient {
             throw new StandardError(500, 'Failed to fetch teams');
         });
     }
+    fetchGroups(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/groups`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid groups response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch groups:', err);
+            throw new StandardError(500, 'Failed to fetch groups');
+        });
+    }
     fetchSkills(body = {}, cancelToken, headers = {}) {
         if (!this.companyId || this.companyId.trim() === '') {
             throw new StandardError(400, 'Company ID is required');

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/index.d.ts

@@ -1,4 +1,5 @@
 export { AvroQueryClientConfig, AvroQueryClient } from './client/QueryClient';
+export { AvroQueryClientProvider } from './client/AvroQueryClientProvider';
 export { AuthManager } from './auth/AuthManager';
 export { MemoryStorage, LocalStorage } from './auth/storage';
 import './client/core/xhr';
@@ -19,6 +20,7 @@ import './client/hooks/plans';
 import './client/hooks/analytics';
 import './client/hooks/avro';
 import './client/hooks/teams';
+import './client/hooks/groups';
 import './client/hooks/skills';
 export * from './types/api';
 export * from './types/auth';

package/dist/index.js

@@ -1,4 +1,5 @@
 export { AvroQueryClient } from './client/QueryClient';
+export { AvroQueryClientProvider } from './client/AvroQueryClientProvider';
 export { AuthManager } from './auth/AuthManager';
 export { MemoryStorage, LocalStorage } from './auth/storage';
 import './client/core/xhr';
@@ -19,6 +20,7 @@ import './client/hooks/plans';
 import './client/hooks/analytics';
 import './client/hooks/avro';
 import './client/hooks/teams';
+import './client/hooks/groups';
 import './client/hooks/skills';
 export * from './types/api';
 export * from './types/auth';

package/package.json

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