fix(folders): gate the orphan fallback on a resolved folder index, not a loading flag

The URL heal was fixed to use `isSuccess && !isPlaceholderData`, but the list filters that
decide "this resource's folderId does not resolve, so show it at the root" were left on
`isLoading` — the same footgun, one layer down.

`isLoading` is false for a disabled query (no workspaceId), false for an errored one, and —
because `useFolders` sets `keepPreviousData` — false while the previous workspace's folders are
still on screen during a switch. In all three the index is empty or belongs to another
workspace, so every foldered knowledge base and table was treated as an orphan and dragged to
the root, or filtered out of a deep-linked folder entirely. A transient fetch failure was enough
to make a folder look empty.

`useFolderNavigation` now exposes `foldersResolved` instead of `isLoading`, so the heal and both
list filters share one signal and the footgun is no longer reachable from the hook's surface.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/components/folders/use-folder-navigation.ts

@@ -29,7 +29,16 @@ export interface FolderNavigation {
   /** Every active folder in this resource's tree, as returned by the folders API. */
   folders: WorkflowFolder[]
   folderById: Map<string, WorkflowFolder>
-  isLoading: boolean
+  /**
+   * Whether `folders`/`folderById` can be trusted to be the COMPLETE set for this workspace.
+   *
+   * Deliberately exposed instead of `isLoading`, which is a footgun here: it is false for a
+   * disabled query (no `workspaceId`), false for an errored one, and — because `useFolders`
+   * sets `keepPreviousData` — false while the previous workspace's folders are still on screen
+   * during a switch. A caller deciding "this resource's `folderId` does not resolve, so treat it
+   * as an orphan" off `isLoading` would dump every foldered row at the root in all three.
+   */
+  foldersResolved: boolean
 }
 
 const EMPTY_FOLDERS: WorkflowFolder[] = []
@@ -54,7 +63,6 @@ export function useFolderNavigation({
 
   const {
     data: folders = EMPTY_FOLDERS,
-    isLoading,
     isSuccess,
     isPlaceholderData,
   } = useFolders(workspaceId, { resourceType })
@@ -67,7 +75,7 @@ export function useFolderNavigation({
    * folders during a workspace switch. In all three the list is empty or stale, and healing
    * off it would throw away a perfectly good folder.
    */
-  const foldersAreAuthoritative = isSuccess && !isPlaceholderData
+  const foldersResolved = isSuccess && !isPlaceholderData
 
   const setCurrentFolderId = useCallback(
     (folderId: string | null) => {
@@ -92,18 +100,19 @@ export function useFolderNavigation({
    * and upload actions keep targeting that id, so a new resource is filed somewhere nothing
    * can reach.
    *
-   * Waits for `isLoading` so an empty index mid-fetch never evicts a perfectly good id.
+   * Gated on {@link FolderNavigation.foldersResolved} so an empty or stale index never evicts a
+   * perfectly good id.
    */
   useEffect(() => {
-    if (!foldersAreAuthoritative || !currentFolderId || folderById.has(currentFolderId)) return
+    if (!foldersResolved || !currentFolderId || folderById.has(currentFolderId)) return
     /**
      * `history: 'replace'`, overriding the `push` these params default to. Opening a folder is
      * a navigation and belongs in the back stack; correcting a URL that never pointed anywhere
      * is not. Pushing here strands the user: Back returns to the dead `?folderId=`, which heals
      * and pushes again, so Back never escapes the page.
      */
     void setFolderParams({ folderId: null }, { history: 'replace' })
-  }, [foldersAreAuthoritative, currentFolderId, folderById, setFolderParams])
+  }, [foldersResolved, currentFolderId, folderById, setFolderParams])
 
   const breadcrumbs = useMemo(() => {
     if (!currentFolderId) return EMPTY_FOLDERS
@@ -135,6 +144,6 @@ export function useFolderNavigation({
     breadcrumbs,
     folders,
     folderById,
-    isLoading,
+    foldersResolved,
   }
 }

apps/sim/app/workspace/[workspaceId]/knowledge/knowledge.tsx

@@ -193,17 +193,11 @@ export function Knowledge() {
   const { mutateAsync: updateKnowledgeBaseMutation } = useUpdateKnowledgeBase(workspaceId)
   const { mutateAsync: deleteKnowledgeBaseMutation } = useDeleteKnowledgeBase(workspaceId)
 
-  const {
-    currentFolderId,
-    setCurrentFolderId,
-    breadcrumbs,
-    folders,
-    folderById,
-    isLoading: foldersLoading,
-  } = useFolderNavigation({
-    resourceType: FOLDER_RESOURCE_TYPE,
-    workspaceId,
-  })
+  const { currentFolderId, setCurrentFolderId, breadcrumbs, folders, folderById, foldersResolved } =
+    useFolderNavigation({
+      resourceType: FOLDER_RESOURCE_TYPE,
+      workspaceId,
+    })
 
   const createFolder = useCreateFolder()
   const updateFolder = useUpdateFolder()
@@ -432,13 +426,15 @@ export function Knowledge() {
      * A `folderId` that no longer names an active folder — a base restored on its own out of
      * Recently Deleted while its folder stayed archived, or a cascade that failed partway —
      * would otherwise match no level at all and leave the base unreachable from every view.
-     * Fall it back to the root instead. Skipped while the folder list is still loading, when
-     * an empty index would transiently drag every base to the root.
+     * Fall it back to the root instead — but only once `foldersResolved` says the index is the
+     * complete set for THIS workspace. Gating on a loading flag instead would treat an errored
+     * fetch, a disabled query, or the previous workspace's cached folders as "no such folder"
+     * and drag every foldered base to the root.
      */
     let result = filterKnowledgeBases(knowledgeBases, debouncedSearchQuery).filter((kb) => {
       const folderId = kb.folderId ?? null
       const effectiveFolderId =
-        foldersLoading || !folderId || folderById.has(folderId) ? folderId : null
+        !foldersResolved || !folderId || folderById.has(folderId) ? folderId : null
       return effectiveFolderId === currentFolderId
     })
 
@@ -507,7 +503,7 @@ export function Knowledge() {
     knowledgeBases,
     currentFolderId,
     folderById,
-    foldersLoading,
+    foldersResolved,
     debouncedSearchQuery,
     connectorFilter,
     contentFilter,

apps/sim/app/workspace/[workspaceId]/tables/tables.tsx

@@ -127,7 +127,7 @@ export function Tables() {
     breadcrumbs: folderChain,
     folders,
     folderById,
-    isLoading: foldersLoading,
+    foldersResolved,
   } = useFolderNavigation({
     resourceType: 'table',
     workspaceId,
@@ -302,13 +302,15 @@ export function Tables() {
      * A `folderId` that no longer names an active folder — restored on its own out
      * of Recently Deleted while its folder stayed archived — would otherwise match
      * no level at all and leave the table unreachable from every view. Fall it back
-     * to the root instead. Skipped while the folder list is still loading, when an
-     * empty index would transiently drag every table to the root.
+     * to the root instead — but only once `foldersResolved` says the index is the complete
+     * set for THIS workspace. Gating on a loading flag instead would treat an errored fetch,
+     * a disabled query, or the previous workspace's cached folders as "no such folder" and
+     * drag every foldered table to the root.
      */
     let result = tables.filter((t) => {
       const folderId = t.folderId ?? null
       const effectiveFolderId =
-        foldersLoading || !folderId || folderById.has(folderId) ? folderId : null
+        !foldersResolved || !folderId || folderById.has(folderId) ? folderId : null
       return effectiveFolderId === currentFolderId
     })
     if (query) result = result.filter((t) => t.name.toLowerCase().includes(query))
@@ -361,7 +363,7 @@ export function Tables() {
     tables,
     currentFolderId,
     folderById,
-    foldersLoading,
+    foldersResolved,
     debouncedSearchTerm,
     rowCountFilter,
     ownerFilter,