fix: online presence issue

Author: Arunkoo

Client/src/pages/DashBoard.tsx

@@ -10,6 +10,7 @@ import {
   useInviteUser,
 } from "../store/workspace.store";
 import type { WorkspaceRole } from "../api/workspace.api";
+import type { WorkspaceWithRole } from "../store/workspace.store";
 
 const ROLE_COLORS: Record<WorkspaceRole, string> = {
   Owner: "bg-gradient-to-r from-purple-500 to-pink-500",
@@ -38,26 +39,30 @@ const Dashboard: React.FC = () => {
 
   const ITEMS_PER_PAGE = 6;
 
+  // ✅ Fetch workspace metadata once
   useEffect(() => {
-    if (user?.id) {
-      // fetch workspaces on mount and after user id changes
+    if (user?.id && workspaces.length === 0) {
       fetchWorkspaces().catch((err) =>
         console.error("Failed to fetch workspaces:", err)
       );
     }
-  }, [user?.id, fetchWorkspaces]);
+  }, [user?.id, fetchWorkspaces, workspaces.length]);
 
   const handleSendInvite = async (workspaceId: string, email: string) => {
     if (!email.trim()) return;
 
     try {
-      // send invite
       await inviteUser(workspaceId, email.trim());
 
-      // refetch workspaces to reflect new invite immediately
-      await fetchWorkspaces();
+      // ✅ Optional: update state locally
+      const wsIndex = workspaces.findIndex((w) => w.id === workspaceId);
+      if (wsIndex !== -1) {
+        const updated: WorkspaceWithRole = {
+          ...workspaces[wsIndex],
+        };
+        workspaces[wsIndex] = updated;
+      }
 
-      // reset modal
       setInviteOpen(null);
       setInviteEmail("");
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -72,8 +77,9 @@ const Dashboard: React.FC = () => {
   const handleCreate = async (e: React.FormEvent) => {
     e.preventDefault();
     if (!newWorkspaceName.trim()) return;
-    await createWorkspace({ name: newWorkspaceName.trim() });
-    setNewWorkspaceName("");
+
+    const ws = await createWorkspace({ name: newWorkspaceName.trim() });
+    if (ws) setNewWorkspaceName("");
   };
 
   const filteredWorkspaces =

Client/src/store/workspace.store.ts

@@ -3,42 +3,32 @@ import {
   type Workspace,
   type WorkspaceMember,
   type WorkspaceRole,
-  type WorkspaceWithMembers,
   type CreateWorkspaceDto,
   workspaceApi,
 } from "../api/workspace.api";
-
-import { useAuthStore } from "./auth.store";
+// import { useAuthStore } from "./auth.store";
 
 export interface WorkspaceWithRole extends Workspace {
   currentUserRole: WorkspaceRole;
 }
 
 interface WorkspaceState {
-  workspaces: WorkspaceWithRole[]; // list
+  workspaces: WorkspaceWithRole[];
   currentWorkspace:
     | (WorkspaceWithRole & { members?: WorkspaceMember[] })
     | null;
   isLoading: boolean;
   error: string | null;
 
   fetchWorkspaces: () => Promise<void>;
-  fetchWorkspace: (id: string) => Promise<void>;
   createWorkspace: (
     dto: CreateWorkspaceDto
   ) => Promise<WorkspaceWithRole | null>;
-  updateWorkspaceName: (
-    id: string,
-    name: string
-  ) => Promise<WorkspaceWithRole | null>;
-  deleteWorkspace: (id: string) => Promise<void>;
-  leaveWorkspace: (id: string) => Promise<void>;
   inviteUser: (workspaceId: string, email: string) => Promise<void>;
-
   reset: () => void;
 }
 
-// Map list membership -> WorkspaceWithRole
+// map membership -> WorkspaceWithRole
 const membershipToWorkspaceWithRole = (
   membership: WorkspaceMember
 ): WorkspaceWithRole => {
@@ -53,30 +43,6 @@ const membershipToWorkspaceWithRole = (
   };
 };
 
-// Map single workspace (with members) -> WorkspaceWithRole (+members)
-const workspaceWithMembersToWorkspaceWithRole = (
-  workspace: WorkspaceWithMembers,
-  currentUserId?: string
-): WorkspaceWithRole & { members: WorkspaceMember[] } => {
-  let role: WorkspaceRole = "Viewer";
-  if (currentUserId && workspace.members) {
-    const m = workspace.members.find((m) => m.userId === currentUserId);
-    if (m) {
-      role = m.role;
-    }
-  }
-
-  return {
-    id: workspace.id,
-    name: workspace.name,
-    ownerId: workspace.ownerId,
-    createdAt: workspace.createdAt,
-    updatedAt: workspace.updatedAt,
-    currentUserRole: role,
-    members: workspace.members,
-  };
-};
-
 export const useWorkspaceStore = create<WorkspaceState>((set) => ({
   workspaces: [],
   currentWorkspace: null,
@@ -86,7 +52,7 @@ export const useWorkspaceStore = create<WorkspaceState>((set) => ({
   fetchWorkspaces: async () => {
     set({ isLoading: true, error: null });
     try {
-      const memberships = await workspaceApi.getUserWorkspaces(); // WorkspaceMember[]
+      const memberships = await workspaceApi.getUserWorkspaces();
       const data = memberships.map(membershipToWorkspaceWithRole);
       set({ workspaces: data, isLoading: false });
     } catch (err: unknown) {
@@ -96,29 +62,19 @@ export const useWorkspaceStore = create<WorkspaceState>((set) => ({
     }
   },
 
-  fetchWorkspace: async (id: string) => {
-    set({ isLoading: true, error: null });
-    try {
-      const raw = await workspaceApi.getWorkspaceById(id); // WorkspaceWithMembers
-      const currentUser = useAuthStore.getState().user;
-      const ws = workspaceWithMembersToWorkspaceWithRole(raw, currentUser?.id);
-      set({ currentWorkspace: ws, isLoading: false });
-    } catch (err: unknown) {
-      const message =
-        err instanceof Error ? err.message : "Failed to load workspace";
-      set({ error: message, isLoading: false, currentWorkspace: null });
-    }
-  },
-
   createWorkspace: async (dto: CreateWorkspaceDto) => {
     set({ isLoading: true, error: null });
     try {
-      const created = await workspaceApi.createWorkspace(dto); // WorkspaceWithMembers
-      const currentUser = useAuthStore.getState().user;
-      const ws = workspaceWithMembersToWorkspaceWithRole(
-        created,
-        currentUser?.id
-      );
+      const created = await workspaceApi.createWorkspace(dto);
+      // const currentUser = useAuthStore.getState().user;
+      const ws: WorkspaceWithRole = {
+        id: created.id,
+        name: created.name,
+        ownerId: created.ownerId,
+        createdAt: created.createdAt,
+        updatedAt: created.updatedAt,
+        currentUserRole: "Owner",
+      };
 
       set((state) => ({
         workspaces: [...state.workspaces, ws],
@@ -134,66 +90,6 @@ export const useWorkspaceStore = create<WorkspaceState>((set) => ({
     }
   },
 
-  updateWorkspaceName: async (id: string, name: string) => {
-    set({ isLoading: true, error: null });
-    try {
-      const updated = await workspaceApi.updateWorkspaceName(id, name); // WorkspaceWithMembers
-      const currentUser = useAuthStore.getState().user;
-      const ws = workspaceWithMembersToWorkspaceWithRole(
-        updated,
-        currentUser?.id
-      );
-
-      set((state) => ({
-        workspaces: state.workspaces.map((w) => (w.id === id ? ws : w)),
-        currentWorkspace:
-          state.currentWorkspace?.id === id ? ws : state.currentWorkspace,
-        isLoading: false,
-      }));
-
-      return ws;
-    } catch (err: unknown) {
-      const message =
-        err instanceof Error ? err.message : "Failed to update workspace";
-      set({ error: message, isLoading: false });
-      return null;
-    }
-  },
-
-  deleteWorkspace: async (id: string) => {
-    set({ isLoading: true, error: null });
-    try {
-      await workspaceApi.deleteWorkspace(id);
-      set((state) => ({
-        workspaces: state.workspaces.filter((w) => w.id !== id),
-        currentWorkspace:
-          state.currentWorkspace?.id === id ? null : state.currentWorkspace,
-        isLoading: false,
-      }));
-    } catch (err: unknown) {
-      const message =
-        err instanceof Error ? err.message : "Failed to delete workspace";
-      set({ error: message, isLoading: false });
-    }
-  },
-
-  leaveWorkspace: async (id: string) => {
-    set({ isLoading: true, error: null });
-    try {
-      await workspaceApi.leaveWorkspace(id);
-      set((state) => ({
-        workspaces: state.workspaces.filter((w) => w.id !== id),
-        currentWorkspace:
-          state.currentWorkspace?.id === id ? null : state.currentWorkspace,
-        isLoading: false,
-      }));
-    } catch (err: unknown) {
-      const message =
-        err instanceof Error ? err.message : "Failed to leave workspace";
-      set({ error: message, isLoading: false });
-    }
-  },
-
   inviteUser: async (workspaceId: string, email: string) => {
     set({ isLoading: true, error: null });
     try {
@@ -216,22 +112,10 @@ export const useWorkspaceStore = create<WorkspaceState>((set) => ({
 }));
 
 export const useWorkspaces = () => useWorkspaceStore((s) => s.workspaces);
-export const useWorkspaceCurrent = () =>
-  useWorkspaceStore((s) => s.currentWorkspace);
 export const useWorkspaceLoading = () => useWorkspaceStore((s) => s.isLoading);
-export const useWorkspaceError = () => useWorkspaceStore((s) => s.error);
-
 export const useFetchWorkspaces = () =>
   useWorkspaceStore((s) => s.fetchWorkspaces);
-export const useFetchWorkspace = () =>
-  useWorkspaceStore((s) => s.fetchWorkspace);
 export const useCreateWorkspace = () =>
   useWorkspaceStore((s) => s.createWorkspace);
-export const useUpdateWorkspaceName = () =>
-  useWorkspaceStore((s) => s.updateWorkspaceName);
-export const useDeleteWorkspace = () =>
-  useWorkspaceStore((s) => s.deleteWorkspace);
-export const useLeaveWorkspace = () =>
-  useWorkspaceStore((s) => s.leaveWorkspace);
 export const useInviteUser = () => useWorkspaceStore((s) => s.inviteUser);
 export const useResetWorkspaces = () => useWorkspaceStore((s) => s.reset);