fix(frontend): Correct error handling for organization

legalconsenthub/stores/useOrganizationStore.ts

@@ -21,8 +21,17 @@ export const useOrganizationStore = defineStore('Organization', () => {
   const toast = useToast()
 
   async function createOrganization(name: string, slug: string, logo?: string) {
-    try {
+    const { data: slugCheck, error: slugError } = await organizationApi.checkSlugAvailability(slug)
-      const { data: slugCheck } = await organizationApi.checkSlugAvailability(slug)
+    if (slugError) {
+      toast.add({
+        title: 'Error checking slug availability',
+        description: slugError.message,
+        color: 'error'
+      })
+      console.error('Error checking slug availability:', slugError)
+      return Promise.reject(slugError)
+    }
+
     if (!slugCheck?.status) {
       toast.add({
         title: 'Slug already taken',
@@ -32,7 +41,13 @@ export const useOrganizationStore = defineStore('Organization', () => {
       return Promise.reject()
     }
 
-      const { data: createdOrganization } = await organizationApi.createOrganization(name, slug, logo)
+    const { data: createdOrganization, error } = await organizationApi.createOrganization(name, slug, logo)
+    if (error) {
+      toast.add({ title: 'Error creating organization', color: 'error' })
+      console.error('Error creating organization:', error)
+      return Promise.reject(error)
+    }
+
     if (createdOrganization) {
       organizations.value.push(createdOrganization)
       toast.add({ title: 'Organization created successfully', color: 'success' })
@@ -43,154 +58,167 @@ export const useOrganizationStore = defineStore('Organization', () => {
 
       return createdOrganization
     }
-    } catch (e) {
-      toast.add({ title: 'Error creating organization', color: 'error' })
-      console.error('Error creating organization:', e)
-    }
   }
 
   async function deleteOrganization(organizationId?: string) {
-    try {
     const idToDelete = organizationId ?? activeOrganization.value?.id
     if (!idToDelete) {
-        throw Error(`No organization is selected for deletion`)
+      const error = new Error('No organization is selected for deletion')
+      toast.add({ title: 'Error deleting organization', color: 'error' })
+      console.error('Error deleting organization:', error)
+      return Promise.reject(error)
     }
-      await organizationApi.deleteOrganization(idToDelete)
+
+    const { error } = await organizationApi.deleteOrganization(idToDelete)
+    if (error) {
+      toast.add({ title: 'Error deleting organization', color: 'error' })
+      console.error('Error deleting organization:', error)
+      return Promise.reject(error)
+    }
+
     organizations.value = organizations.value.filter((org) => org.id !== organizationId)
     toast.add({ title: 'Organization deleted successfully', color: 'success' })
-    } catch (e) {
-      toast.add({ title: 'Error deleting organization', color: 'error' })
-      console.error('Error deleting organization:', e)
-    }
   }
 
   async function getInvitation(invitationId: string): Promise<CustomInvitation> {
-    try {
+    const { data: invitation, error } = await organizationApi.getInvitation(invitationId)
-      const { data: invitation } = await organizationApi.getInvitation(invitationId)
+    if (error) {
-      return invitation
+      toast.add({ title: error.message, color: 'error' })
-    } catch (e) {
+      console.error('Error getting invitation:', error)
-      console.error('Error getInvitation:', e)
+      return Promise.reject(error)
-      return null
     }
+    return invitation
   }
 
   async function loadInvitations(organizationId?: string) {
-    try {
+    const { data: loadedInvitations, error } = await organizationApi.listInvitations(organizationId)
-      const { data: loadedInvitations } = await organizationApi.listInvitations(organizationId)
+    if (error) {
+      toast.add({ title: 'Error loading invitations', color: 'error' })
+      console.error('Error loading invitations:', error)
+      return Promise.reject(error)
+    }
+
     if (loadedInvitations) {
       invitations.value = loadedInvitations
     }
-    } catch (e) {
-      toast.add({ title: 'Error loading invitations', color: 'error' })
-      console.error('Error loading invitations:', e)
-    }
   }
 
   async function inviteMember(email: string, role: LegalRole) {
-    try {
+    const { error } = await organizationApi.inviteMember(email, role)
-      await organizationApi.inviteMember(email, role)
+    if (error) {
+      toast.add({ title: 'Error inviting member', color: 'error' })
+      console.error('Error inviting member:', error)
+      return Promise.reject(error)
+    }
+
     await loadInvitations()
     toast.add({ title: 'Member invited successfully', color: 'success' })
-    } catch (e) {
-      toast.add({ title: 'Error inviting member', color: 'error' })
-      console.error('Error inviting member:', e)
-    }
   }
 
   async function removeMember(memberId: string) {
-    try {
+    const { error } = await organizationApi.removeMember(memberId)
-      await organizationApi.removeMember(memberId)
+    if (error) {
-      activeOrganizationMembers.value = activeOrganizationMembers.value.filter(
-        (member: Member) => member.id !== memberId
-      )
-      toast.add({ title: 'Member removed successfully', color: 'success' })
-    } catch (e) {
       toast.add({ title: 'Error removing member', color: 'error' })
-      console.error('Error removing member:', e)
+      console.error('Error removing member:', error)
+      return Promise.reject(error)
     }
+
+    activeOrganizationMembers.value = activeOrganizationMembers.value.filter((member: Member) => member.id !== memberId)
+    toast.add({ title: 'Member removed successfully', color: 'success' })
   }
 
   async function acceptInvitation(invitationId: string) {
-    try {
+    const { error } = await organizationApi.acceptInvitation(invitationId)
-      await organizationApi.acceptInvitation(invitationId)
+    if (error) {
+      toast.add({ title: 'Error accepting invitation', color: 'error' })
+      console.error('Error accepting invitation:', error)
+      return Promise.reject(error)
+    }
+
     await navigateTo('/')
     await syncUserRoleToBackend()
-    } catch (e) {
-      toast.add({ title: 'Error accepting invitation', color: 'error' })
-      console.error('Error accepting invitation:', e)
-    }
   }
 
   async function syncUserRoleToBackend() {
-    try {
     const { updateUser } = useUser()
     const { user } = useAuth()
 
     if (!user.value?.id) {
+      const error = new Error('No user ID available for role sync')
       console.warn('No user ID available for role sync')
-        return
+      return Promise.reject(error)
     }
 
     // Call updateUser without userDto to trigger JWT-based sync
-      await updateUser(user.value.id)
+    const updatedUser = await updateUser(user.value.id)
-
+    if (updatedUser) {
       console.log('Successfully synced user role to backend from JWT')
-    } catch (error) {
-      console.error('Failed to sync user role to backend from JWT:', error)
-      // Don't throw - role sync failure shouldn't prevent invitation acceptance
     }
   }
 
   async function cancelSentInvitation(invitationId: string) {
-    try {
+    const { error } = await organizationApi.cancelSentInvitation(invitationId)
-      await organizationApi.cancelSentInvitation(invitationId)
+    if (error) {
-      invitations.value = invitations.value.filter((invitation) => invitation.id !== invitationId)
-    } catch (e) {
       toast.add({ title: 'Error rejecting invitation', color: 'error' })
-      console.error('Error rejecting invitation:', e)
+      console.error('Error rejecting invitation:', error)
+      return Promise.reject(error)
     }
+
+    invitations.value = invitations.value.filter((invitation) => invitation.id !== invitationId)
   }
 
   async function rejectInvitation(invitationId: string) {
-    try {
+    const { error } = await organizationApi.rejectInvitation(invitationId)
-      await organizationApi.rejectInvitation(invitationId)
+    if (error) {
-      invitations.value = invitations.value.filter((invitation) => invitation.id !== invitationId)
-    } catch (e) {
       toast.add({ title: 'Error rejecting invitation', color: 'error' })
-      console.error('Error rejecting invitation:', e)
+      console.error('Error rejecting invitation:', error)
+      return Promise.reject(error)
     }
+
+    invitations.value = invitations.value.filter((invitation) => invitation.id !== invitationId)
   }
 
   async function loadOrganizations() {
-    try {
+    const { data: loadedOrganizations, error } = await organizationApi.loadOrganizations()
-      const { data: loadedOrganizations } = await organizationApi.loadOrganizations()
+    if (error) {
+      toast.add({ title: 'Error loading organizations', color: 'error' })
+      console.error('Error loading organizations:', error)
+      return Promise.reject(error)
+    }
+
     if (loadedOrganizations) {
       organizations.value = loadedOrganizations
     }
-    } catch (e) {
-      toast.add({ title: 'Error loading organizations', color: 'error' })
-      console.error('Error loading organizations:', e)
-    }
   }
 
   async function setActiveOrganization(organizationId: string) {
-    try {
+    const { data: activeOrganizationToSet, error } = await organizationApi.setActiveOrganization(organizationId)
-      const { data: activeOrganizationToSet } = await organizationApi.setActiveOrganization(organizationId)
+    if (error) {
+      toast.add({ title: 'Error setting active organizations', color: 'error' })
+      console.error('Error setting active organizations:', error)
+      return Promise.reject(error)
+    }
+
     activeOrganization.value = activeOrganizationToSet
 
-      const { data: invitationsToSet } = await organizationApi.listInvitations(activeOrganizationToSet?.id)
+    const { data: invitationsToSet, error: invitationsError } = await organizationApi.listInvitations(
+      activeOrganizationToSet?.id
+    )
+    if (invitationsError) {
+      console.error('Error loading invitations for active organization:', invitationsError)
+    } else {
       invitations.value = invitationsToSet ?? []
+    }
 
     await loadMembers()
-    } catch (e) {
-      toast.add({ title: 'Error setting active organizations', color: 'error' })
-      console.error('Error setting active organizations:', e)
-    }
   }
 
   async function loadMembers(options?: Omit<NonNullable<ListMembersQuery>, 'organizationId'>) {
-    try {
+    if (!activeOrganization.value?.id) {
-      if (!activeOrganization.value?.id) return null
+      const error = new Error('No active organization to load members for')
+      console.error('Error getting members: No active organization')
+      return Promise.reject(error)
+    }
 
     const memberOptions: ListMembersOptions = {
       query: {
@@ -199,12 +227,14 @@ export const useOrganizationStore = defineStore('Organization', () => {
       }
     }
 
-      const { data: response } = await organizationApi.listMembers(memberOptions)
+    const { data: response, error } = await organizationApi.listMembers(memberOptions)
-      activeOrganizationMembers.value = response?.members ?? []
+    if (error) {
-    } catch (e) {
       toast.add({ title: 'Error getting members', color: 'error' })
-      console.error('Error getting members:', e)
+      console.error('Error getting members:', error)
+      return Promise.reject(error)
     }
+
+    activeOrganizationMembers.value = response?.members ?? []
   }
 
   return {
@@ -215,7 +245,6 @@ export const useOrganizationStore = defineStore('Organization', () => {
     deleteOrganization,
     invitations,
     getInvitation,
-    loadInvitations,
     inviteMember,
     removeMember,
     acceptInvitation,