Spaces:
Running
Running
| import { | |
| createContext, | |
| useCallback, | |
| useContext, | |
| useEffect, | |
| useMemo, | |
| useState, | |
| } from "react"; | |
| import { useLocation, useNavigate, useParams } from "react-router-dom"; | |
| import { | |
| createWorkspace as createWorkspaceRequest, | |
| fetchWorkspaces, | |
| getSession, | |
| updateWorkspace as updateWorkspaceRequest, | |
| workspaceApiFetch, | |
| type CreateWorkspaceInput, | |
| type UpdateWorkspaceInput, | |
| type Workspace, | |
| } from "../lib/api"; | |
| import { resolveRoutedWorkspace, switchWorkspacePath, workspacePath } from "./workspaceRoutes"; | |
| interface WorkspaceContextValue { | |
| workspaces: Workspace[]; | |
| activeWorkspace: Workspace | null; | |
| requestedSlug?: string; | |
| loading: boolean; | |
| error: string | null; | |
| notFound: boolean; | |
| canManageWorkspaces: boolean; | |
| refreshWorkspaces: () => Promise<Workspace[]>; | |
| switchWorkspace: (slug: string) => void; | |
| createWorkspace: (input: CreateWorkspaceInput) => Promise<Workspace>; | |
| updateWorkspace: (input: UpdateWorkspaceInput) => Promise<Workspace>; | |
| apiFetch: <T>(path: string, options?: RequestInit) => Promise<T>; | |
| } | |
| const WorkspaceContext = createContext<WorkspaceContextValue | null>(null); | |
| export function WorkspaceProvider({ children }: { children: React.ReactNode }) { | |
| const { workspaceSlug } = useParams(); | |
| const location = useLocation(); | |
| const navigate = useNavigate(); | |
| const session = getSession(); | |
| const [workspaces, setWorkspaces] = useState<Workspace[]>([]); | |
| const [loading, setLoading] = useState(true); | |
| const [error, setError] = useState<string | null>(null); | |
| const refreshWorkspaces = useCallback(async () => { | |
| setLoading(true); | |
| setError(null); | |
| try { | |
| const items = await fetchWorkspaces(); | |
| setWorkspaces(items); | |
| return items; | |
| } catch (reason) { | |
| setError(reason instanceof Error ? reason.message : "Unable to load workspaces"); | |
| return []; | |
| } finally { | |
| setLoading(false); | |
| } | |
| }, []); | |
| useEffect(() => { | |
| void refreshWorkspaces(); | |
| }, [refreshWorkspaces]); | |
| const activeWorkspace = useMemo( | |
| () => resolveRoutedWorkspace(workspaces, workspaceSlug), | |
| [workspaceSlug, workspaces], | |
| ); | |
| const notFound = !loading && Boolean(workspaceSlug) && !activeWorkspace; | |
| const switchWorkspace = useCallback( | |
| (slug: string) => navigate(switchWorkspacePath(location.pathname, slug)), | |
| [location.pathname, navigate], | |
| ); | |
| const createWorkspace = useCallback( | |
| async (input: CreateWorkspaceInput) => { | |
| const created = await createWorkspaceRequest(input); | |
| await refreshWorkspaces(); | |
| navigate(workspacePath(created.slug)); | |
| return created; | |
| }, | |
| [navigate, refreshWorkspaces], | |
| ); | |
| const updateWorkspace = useCallback( | |
| async (input: UpdateWorkspaceInput) => { | |
| if (!activeWorkspace) throw new Error("No active workspace"); | |
| const updated = await updateWorkspaceRequest(activeWorkspace.slug, input); | |
| await refreshWorkspaces(); | |
| return updated; | |
| }, | |
| [activeWorkspace, refreshWorkspaces], | |
| ); | |
| const scopedFetch = useCallback( | |
| <T,>(path: string, options: RequestInit = {}) => { | |
| if (!activeWorkspace || activeWorkspace.archived) { | |
| return Promise.reject(new Error("No active workspace")); | |
| } | |
| return workspaceApiFetch<T>(activeWorkspace, path, options); | |
| }, | |
| [activeWorkspace], | |
| ); | |
| return ( | |
| <WorkspaceContext.Provider | |
| value={{ | |
| workspaces, | |
| activeWorkspace, | |
| requestedSlug: workspaceSlug, | |
| loading, | |
| error, | |
| notFound, | |
| canManageWorkspaces: Boolean(session?.isSystemPat), | |
| refreshWorkspaces, | |
| switchWorkspace, | |
| createWorkspace, | |
| updateWorkspace, | |
| apiFetch: scopedFetch, | |
| }} | |
| > | |
| {children} | |
| </WorkspaceContext.Provider> | |
| ); | |
| } | |
| export function useWorkspace(): WorkspaceContextValue { | |
| const value = useContext(WorkspaceContext); | |
| if (!value) throw new Error("useWorkspace must be used inside WorkspaceProvider"); | |
| return value; | |
| } | |