@sudobility/shapeshyft_client 0.0.54 → 0.0.55

package/dist/hooks/useEntities.js

@@ -1,395 +1,298 @@
-import { useCallback, useMemo, useState } from 'react';
+import { useCallback, useMemo } from 'react';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { ShapeshyftClient } from '../network/ShapeshyftClient';
-export const useEntities = (networkClient, baseUrl, testMode = false) => {
+import { QUERY_KEYS } from '../types';
+const EMPTY_ENTITIES = [];
+const EMPTY_MEMBERS = [];
+const EMPTY_INVITATIONS = [];
+export const useEntities = (networkClient, baseUrl, token, entitySlug, options) => {
+    const testMode = options?.testMode ?? false;
+    const enabled = (options?.enabled ?? true) && !!token;
+    const entityEnabled = enabled && !!entitySlug;
     const client = useMemo(() => new ShapeshyftClient({ baseUrl, networkClient, testMode }), [baseUrl, networkClient, testMode]);
-    const [entities, setEntities] = useState([]);
-    const [currentEntity, setCurrentEntity] = useState(null);
-    const [members, setMembers] = useState([]);
-    const [invitations, setInvitations] = useState([]);
-    const [myInvitations, setMyInvitations] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const refreshEntities = useCallback(async (token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
+    const queryClient = useQueryClient();
+    const { data: entitiesData, isLoading: entitiesLoading, error: entitiesError, refetch: refetchEntities, } = useQuery({
+        queryKey: QUERY_KEYS.entities(),
+        queryFn: async () => {
             const response = await client.getEntities(token);
-            if (response.success && response.data) {
-                setEntities(response.data);
+            if (!response.success || !response.data) {
+                throw new Error(response.error || 'Failed to fetch entities');
             }
-            else {
-                setError(response.error || 'Failed to fetch entities');
+            return response.data;
+        },
+        enabled,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+    const { data: membersData, isLoading: membersLoading, refetch: refetchMembers, } = useQuery({
+        queryKey: QUERY_KEYS.entityMembers(entitySlug ?? ''),
+        queryFn: async () => {
+            const response = await client.getEntityMembers(entitySlug, token);
+            if (!response.success || !response.data) {
+                throw new Error(response.error || 'Failed to fetch members');
             }
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to fetch entities';
-            setError(errorMessage);
-            console.error('[useEntities] refreshEntities error:', errorMessage, err);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client]);
-    const getEntity = useCallback(async (entitySlug, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.getEntity(entitySlug, token);
-            if (response.success && response.data) {
-                setCurrentEntity(response.data);
+            return response.data;
+        },
+        enabled: entityEnabled,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+    const { data: invitationsData, isLoading: invitationsLoading, refetch: refetchInvitations, } = useQuery({
+        queryKey: QUERY_KEYS.entityInvitations(entitySlug ?? ''),
+        queryFn: async () => {
+            const response = await client.getEntityInvitations(entitySlug, token);
+            if (!response.success || !response.data) {
+                throw new Error(response.error || 'Failed to fetch invitations');
             }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to get entity';
-            setError(errorMessage);
-            console.error('[useEntities] getEntity error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client]);
-    const createEntity = useCallback(async (data, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.createEntity(data, token);
-            if (response.success) {
-                await refreshEntities(token);
+            return response.data;
+        },
+        enabled: entityEnabled,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+    const { data: myInvitationsData, isLoading: myInvitationsLoading, refetch: refetchMyInvitations, } = useQuery({
+        queryKey: QUERY_KEYS.myInvitations(),
+        queryFn: async () => {
+            const response = await client.getMyInvitations(token);
+            if (!response.success || !response.data) {
+                throw new Error(response.error || 'Failed to fetch my invitations');
             }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to create entity';
-            setError(errorMessage);
-            console.error('[useEntities] createEntity error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshEntities]);
-    const updateEntity = useCallback(async (entitySlug, data, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.updateEntity(entitySlug, data, token);
+            return response.data;
+        },
+        enabled,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+    const createEntityMutation = useMutation({
+        mutationFn: async (data) => {
+            return client.createEntity(data, token);
+        },
+        onSuccess: response => {
             if (response.success) {
-                await refreshEntities(token);
+                queryClient.invalidateQueries({ queryKey: QUERY_KEYS.entities() });
             }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to update entity';
-            setError(errorMessage);
-            console.error('[useEntities] updateEntity error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshEntities]);
-    const deleteEntity = useCallback(async (entitySlug, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.deleteEntity(entitySlug, token);
+        },
+    });
+    const updateEntityMutation = useMutation({
+        mutationFn: async ({ slug, data, }) => {
+            return client.updateEntity(slug, data, token);
+        },
+        onSuccess: response => {
             if (response.success) {
-                await refreshEntities(token);
-            }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to delete entity';
-            setError(errorMessage);
-            console.error('[useEntities] deleteEntity error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshEntities]);
-    const refreshMembers = useCallback(async (entitySlug, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.getEntityMembers(entitySlug, token);
-            if (response.success && response.data) {
-                setMembers(response.data);
+                queryClient.invalidateQueries({ queryKey: QUERY_KEYS.entities() });
             }
-            else {
-                setError(response.error || 'Failed to fetch members');
-            }
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to fetch members';
-            setError(errorMessage);
-            console.error('[useEntities] refreshMembers error:', errorMessage, err);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client]);
-    const updateMemberRole = useCallback(async (entitySlug, memberId, role, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.updateEntityMemberRole(entitySlug, memberId, role, token);
+        },
+    });
+    const deleteEntityMutation = useMutation({
+        mutationFn: async (slug) => {
+            return client.deleteEntity(slug, token);
+        },
+        onSuccess: response => {
             if (response.success) {
-                await refreshMembers(entitySlug, token);
+                queryClient.invalidateQueries({ queryKey: QUERY_KEYS.entities() });
             }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to update member role';
-            setError(errorMessage);
-            console.error('[useEntities] updateMemberRole error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshMembers]);
-    const removeMember = useCallback(async (entitySlug, memberId, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.removeEntityMember(entitySlug, memberId, token);
-            if (response.success) {
-                await refreshMembers(entitySlug, token);
+        },
+    });
+    const updateMemberRoleMutation = useMutation({
+        mutationFn: async ({ memberId, role, }) => {
+            return client.updateEntityMemberRole(entitySlug, memberId, role, token);
+        },
+        onSuccess: response => {
+            if (response.success && entitySlug) {
+                queryClient.invalidateQueries({
+                    queryKey: QUERY_KEYS.entityMembers(entitySlug),
+                });
             }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to remove member';
-            setError(errorMessage);
-            console.error('[useEntities] removeMember error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshMembers]);
-    const refreshInvitations = useCallback(async (entitySlug, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.getEntityInvitations(entitySlug, token);
-            if (response.success && response.data) {
-                setInvitations(response.data);
+        },
+    });
+    const removeMemberMutation = useMutation({
+        mutationFn: async (memberId) => {
+            return client.removeEntityMember(entitySlug, memberId, token);
+        },
+        onSuccess: response => {
+            if (response.success && entitySlug) {
+                queryClient.invalidateQueries({
+                    queryKey: QUERY_KEYS.entityMembers(entitySlug),
+                });
             }
-            else {
-                setError(response.error || 'Failed to fetch invitations');
+        },
+    });
+    const createInvitationMutation = useMutation({
+        mutationFn: async (data) => {
+            return client.createEntityInvitation(entitySlug, data, token);
+        },
+        onSuccess: response => {
+            if (response.success && entitySlug) {
+                queryClient.invalidateQueries({
+                    queryKey: QUERY_KEYS.entityInvitations(entitySlug),
+                });
             }
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to fetch invitations';
-            setError(errorMessage);
-            console.error('[useEntities] refreshInvitations error:', errorMessage, err);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client]);
-    const createInvitation = useCallback(async (entitySlug, data, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.createEntityInvitation(entitySlug, data, token);
-            if (response.success) {
-                await refreshInvitations(entitySlug, token);
+        },
+    });
+    const cancelInvitationMutation = useMutation({
+        mutationFn: async (invitationId) => {
+            return client.cancelEntityInvitation(entitySlug, invitationId, token);
+        },
+        onSuccess: response => {
+            if (response.success && entitySlug) {
+                queryClient.invalidateQueries({
+                    queryKey: QUERY_KEYS.entityInvitations(entitySlug),
+                });
             }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to create invitation';
-            setError(errorMessage);
-            console.error('[useEntities] createInvitation error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshInvitations]);
-    const cancelInvitation = useCallback(async (entitySlug, invitationId, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.cancelEntityInvitation(entitySlug, invitationId, token);
+        },
+    });
+    const acceptInvitationMutation = useMutation({
+        mutationFn: async (invitationToken) => {
+            return client.acceptInvitation(invitationToken, token);
+        },
+        onSuccess: response => {
             if (response.success) {
-                await refreshInvitations(entitySlug, token);
+                queryClient.invalidateQueries({ queryKey: QUERY_KEYS.myInvitations() });
+                queryClient.invalidateQueries({ queryKey: QUERY_KEYS.entities() });
             }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to cancel invitation';
-            setError(errorMessage);
-            console.error('[useEntities] cancelInvitation error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshInvitations]);
-    const refreshMyInvitations = useCallback(async (token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.getMyInvitations(token);
-            if (response.success && response.data) {
-                setMyInvitations(response.data);
-            }
-            else {
-                setError(response.error || 'Failed to fetch my invitations');
-            }
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to fetch my invitations';
-            setError(errorMessage);
-            console.error('[useEntities] refreshMyInvitations error:', errorMessage, err);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client]);
-    const acceptInvitation = useCallback(async (invitationToken, token) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await client.acceptInvitation(invitationToken, token);
+        },
+    });
+    const declineInvitationMutation = useMutation({
+        mutationFn: async (invitationToken) => {
+            return client.declineInvitation(invitationToken, token);
+        },
+        onSuccess: response => {
             if (response.success) {
-                await refreshMyInvitations(token);
-                await refreshEntities(token);
+                queryClient.invalidateQueries({ queryKey: QUERY_KEYS.myInvitations() });
             }
-            return response;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to accept invitation';
-            setError(errorMessage);
-            console.error('[useEntities] acceptInvitation error:', errorMessage, err);
-            return {
-                success: false,
-                error: errorMessage,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshMyInvitations, refreshEntities]);
-    const declineInvitation = useCallback(async (invitationToken, token) => {
-        setIsLoading(true);
-        setError(null);
+        },
+    });
+    const getEntity = useCallback(async (slug) => {
         try {
-            const response = await client.declineInvitation(invitationToken, token);
-            if (response.success) {
-                await refreshMyInvitations(token);
-            }
-            return response;
+            return await client.getEntity(slug, token);
         }
         catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Failed to decline invitation';
-            setError(errorMessage);
-            console.error('[useEntities] declineInvitation error:', errorMessage, err);
+            const errorMessage = err instanceof Error ? err.message : 'Failed to get entity';
             return {
                 success: false,
                 error: errorMessage,
                 timestamp: new Date().toISOString(),
             };
         }
-        finally {
-            setIsLoading(false);
-        }
-    }, [client, refreshMyInvitations]);
+    }, [client, token]);
+    const createEntity = useCallback((data) => createEntityMutation.mutateAsync(data), [createEntityMutation]);
+    const updateEntity = useCallback((slug, data) => updateEntityMutation.mutateAsync({ slug, data }), [updateEntityMutation]);
+    const deleteEntity = useCallback((slug) => deleteEntityMutation.mutateAsync(slug), [deleteEntityMutation]);
+    const updateMemberRole = useCallback((memberId, role) => updateMemberRoleMutation.mutateAsync({ memberId, role }), [updateMemberRoleMutation]);
+    const removeMember = useCallback((memberId) => removeMemberMutation.mutateAsync(memberId), [removeMemberMutation]);
+    const createInvitation = useCallback((data) => createInvitationMutation.mutateAsync(data), [createInvitationMutation]);
+    const cancelInvitation = useCallback((invitationId) => cancelInvitationMutation.mutateAsync(invitationId), [cancelInvitationMutation]);
+    const acceptInvitation = useCallback((invitationToken) => acceptInvitationMutation.mutateAsync(invitationToken), [acceptInvitationMutation]);
+    const declineInvitation = useCallback((invitationToken) => declineInvitationMutation.mutateAsync(invitationToken), [declineInvitationMutation]);
+    const isLoading = entitiesLoading ||
+        membersLoading ||
+        invitationsLoading ||
+        myInvitationsLoading ||
+        createEntityMutation.isPending ||
+        updateEntityMutation.isPending ||
+        deleteEntityMutation.isPending ||
+        updateMemberRoleMutation.isPending ||
+        removeMemberMutation.isPending ||
+        createInvitationMutation.isPending ||
+        cancelInvitationMutation.isPending ||
+        acceptInvitationMutation.isPending ||
+        declineInvitationMutation.isPending;
+    const queryError = entitiesError;
+    const mutationError = createEntityMutation.error ??
+        updateEntityMutation.error ??
+        deleteEntityMutation.error ??
+        updateMemberRoleMutation.error ??
+        removeMemberMutation.error ??
+        createInvitationMutation.error ??
+        cancelInvitationMutation.error ??
+        acceptInvitationMutation.error ??
+        declineInvitationMutation.error;
+    const error = queryError instanceof Error
+        ? queryError.message
+        : mutationError instanceof Error
+            ? mutationError.message
+            : null;
     const clearError = useCallback(() => {
-        setError(null);
-    }, []);
+        createEntityMutation.reset();
+        updateEntityMutation.reset();
+        deleteEntityMutation.reset();
+        updateMemberRoleMutation.reset();
+        removeMemberMutation.reset();
+        createInvitationMutation.reset();
+        cancelInvitationMutation.reset();
+        acceptInvitationMutation.reset();
+        declineInvitationMutation.reset();
+    }, [
+        createEntityMutation,
+        updateEntityMutation,
+        deleteEntityMutation,
+        updateMemberRoleMutation,
+        removeMemberMutation,
+        createInvitationMutation,
+        cancelInvitationMutation,
+        acceptInvitationMutation,
+        declineInvitationMutation,
+    ]);
     const reset = useCallback(() => {
-        setEntities([]);
-        setCurrentEntity(null);
-        setMembers([]);
-        setInvitations([]);
-        setMyInvitations([]);
-        setError(null);
-        setIsLoading(false);
-    }, []);
+        queryClient.removeQueries({ queryKey: QUERY_KEYS.entities() });
+        queryClient.removeQueries({ queryKey: QUERY_KEYS.myInvitations() });
+        if (entitySlug) {
+            queryClient.removeQueries({
+                queryKey: QUERY_KEYS.entityMembers(entitySlug),
+            });
+            queryClient.removeQueries({
+                queryKey: QUERY_KEYS.entityInvitations(entitySlug),
+            });
+        }
+        clearError();
+    }, [queryClient, entitySlug, clearError]);
+    const currentEntity = useMemo(() => entitySlug
+        ? ((entitiesData ?? []).find(e => e.entitySlug === entitySlug) ?? null)
+        : null, [entitiesData, entitySlug]);
     return useMemo(() => ({
-        entities,
+        entities: entitiesData ?? EMPTY_ENTITIES,
         currentEntity,
-        members,
-        invitations,
-        myInvitations,
+        members: membersData ?? EMPTY_MEMBERS,
+        invitations: invitationsData ?? EMPTY_INVITATIONS,
+        myInvitations: myInvitationsData ?? EMPTY_INVITATIONS,
         isLoading,
         error,
-        refreshEntities,
+        refetchEntities,
         getEntity,
         createEntity,
         updateEntity,
         deleteEntity,
-        refreshMembers,
+        refetchMembers,
         updateMemberRole,
         removeMember,
-        refreshInvitations,
+        refetchInvitations,
         createInvitation,
         cancelInvitation,
-        refreshMyInvitations,
+        refetchMyInvitations,
         acceptInvitation,
         declineInvitation,
         clearError,
         reset,
     }), [
-        entities,
+        entitiesData,
         currentEntity,
-        members,
-        invitations,
-        myInvitations,
+        membersData,
+        invitationsData,
+        myInvitationsData,
         isLoading,
         error,
-        refreshEntities,
+        refetchEntities,
         getEntity,
         createEntity,
         updateEntity,
         deleteEntity,
-        refreshMembers,
+        refetchMembers,
         updateMemberRole,
         removeMember,
-        refreshInvitations,
+        refetchInvitations,
         createInvitation,
         cancelInvitation,
-        refreshMyInvitations,
+        refetchMyInvitations,
         acceptInvitation,
         declineInvitation,
         clearError,