chore: lint

Author: appflowy

src/application/services/js-services/http/http_api.ts

@@ -998,7 +998,7 @@ export async function getAppOutline(workspaceId: string): Promise<AppOutlineResp
   }));
 }
 
-export async function getView(workspaceId: string, viewId: string, depth: number = 2) {
+export async function getView(workspaceId: string, viewId: string, depth: number = 1) {
   const url = `/api/workspace/${workspaceId}/view/${viewId}?depth=${depth}`;
 
   return executeAPIRequest<View>(() =>
@@ -2171,7 +2171,7 @@ export async function turnIntoMember(workspaceId: string, email: string) {
 
 
 export async function getShareWithMe(workspaceId: string): Promise<View> {
-  const url = `/api/sharing/workspace/${workspaceId}/view/${workspaceId}?depth=1`;
+  const url = `/api/sharing/workspace/${workspaceId}/view/${workspaceId}?depth=50`;
 
   return executeAPIRequest<View>(() =>
     axiosInstance?.get<APIResponse<View>>(url)

src/components/_shared/outline/mergeOutline.ts

@@ -107,6 +107,16 @@ export function addViewToOutline(
 
   const next = outline.map((view) => {
     if (view.view_id === parentId) {
+      // In lazy outline mode, an unloaded parent can have has_children=true
+      // with empty children. Don't materialize a partial child list in that case.
+      const parentChildrenLoaded = view.children.length > 0 || view.has_children === false;
+
+      if (!parentChildrenLoaded) {
+        if (view.has_children) return view;
+        changed = true;
+        return { ...view, has_children: true };
+      }
+
       // Don't add duplicates
       if (view.children.some((c) => c.view_id === newView.view_id)) {
         return view;

src/components/app/hooks/usePageOperations.ts

@@ -43,14 +43,15 @@ export function usePageOperations({
       try {
         const response = await service?.addAppPage(currentWorkspaceId, parentViewId, payload);
 
-        // Keep current expanded/loaded subtree state. New page is synced via
-        // WebSocket notifications (FolderViewChanged/FolderChanged).
+        // Keep a resilient fallback when realtime delivery is unavailable.
+        // This guarantees sidebar eventual consistency after creation.
+        void loadOutline?.(currentWorkspaceId, false);
         return response;
       } catch (e) {
         return Promise.reject(e);
       }
     },
-    [currentWorkspaceId, service, outline, role]
+    [currentWorkspaceId, service, outline, role, loadOutline]
   );
 
   // Delete a page (move to trash)

src/components/app/layers/AppBusinessLayer.tsx

@@ -79,7 +79,7 @@ export const AppBusinessLayer: React.FC<AppBusinessLayerProps> = ({ children })
   const { loadView, createRow, toView, awarenessMap, getViewIdFromDatabaseId, bindViewSync } = useViewOperations();
 
   // Initialize page operations
-  const pageOperations = usePageOperations({ outline });
+  const pageOperations = usePageOperations({ outline, loadOutline });
 
   // Check if current view has been deleted
   const viewHasBeenDeleted = useMemo(() => {
@@ -130,8 +130,17 @@ export const AppBusinessLayer: React.FC<AppBusinessLayerProps> = ({ children })
     const cacheKey = `${currentWorkspaceId}:${viewId}`;
     const cached = routeViewExistsCacheRef.current.get(cacheKey);
 
-    if (cached !== undefined) {
-      setRouteViewExists(cached);
+    // Cache policy:
+    // - false can be trusted (confirmed not-found)
+    // - true is trusted only while the view is still present in current outline
+    //   to avoid stale positive cache after realtime deletes/moves.
+    if (cached === false) {
+      setRouteViewExists(false);
+      return;
+    }
+
+    if (cached === true && findView(outline ?? [], viewId)) {
+      setRouteViewExists(true);
       return;
     }
 

src/components/app/outline/Outline.tsx

@@ -48,6 +48,8 @@ export function Outline({ width }: { width: number }) {
   >(undefined);
   const loadingViewIdsRef = useRef<Set<string>>(new Set());
   const autoLoadRetryAfterRef = useRef<Map<string, number>>(new Map());
+  const validatingRestoreIdsRef = useRef<Set<string>>(new Set());
+  const validatedExistingRestoreIdsRef = useRef<Set<string>>(new Set());
   const [loadingRevision, setLoadingRevision] = useState(0);
   const [nowMs, setNowMs] = useState(() => Date.now());
   const loadingViewIds = useMemo(() => loadingViewIdsRef.current, [loadingRevision]); // eslint-disable-line react-hooks/exhaustive-deps
@@ -61,9 +63,61 @@ export function Outline({ width }: { width: number }) {
     setPendingAutoLoadIds(restoredExpandedIds);
     loadingViewIdsRef.current = new Set();
     autoLoadRetryAfterRef.current = new Map();
+    validatingRestoreIdsRef.current = new Set();
+    validatedExistingRestoreIdsRef.current = new Set();
     setLoadingRevision((r) => r + 1);
   }, [currentWorkspaceId]);
 
+  // Validate restored expanded IDs that are not in the current tree and prune only truly stale IDs.
+  // This avoids keeping deleted/moved IDs forever, while preserving valid deep IDs.
+  useEffect(() => {
+    if (!outline || outline.length === 0 || !loadViewChildrenBatch || pendingAutoLoadIds.length === 0) return;
+
+    const unknownIds = pendingAutoLoadIds.filter((id) => {
+      if (findView(outline, id)) return false;
+      if (validatedExistingRestoreIdsRef.current.has(id)) return false;
+      if (validatingRestoreIdsRef.current.has(id)) return false;
+      return true;
+    });
+
+    if (unknownIds.length === 0) return;
+
+    unknownIds.forEach((id) => validatingRestoreIdsRef.current.add(id));
+
+    void loadViewChildrenBatch(unknownIds)
+      .then((views) => {
+        const existingIds = new Set((views || []).map((view) => view.view_id));
+        const staleIds = unknownIds.filter((id) => !existingIds.has(id));
+
+        existingIds.forEach((id) => validatedExistingRestoreIdsRef.current.add(id));
+
+        if (staleIds.length === 0) return;
+
+        const staleSet = new Set(staleIds);
+
+        staleIds.forEach((id) => {
+          setOutlineExpands(id, false);
+          loadingViewIdsRef.current.delete(id);
+          autoLoadRetryAfterRef.current.delete(id);
+        });
+
+        setPendingAutoLoadIds((prev) => {
+          const next = prev.filter((id) => !staleSet.has(id));
+
+          return next.length === prev.length ? prev : next;
+        });
+        setExpandViewIds((prev) => {
+          const next = prev.filter((id) => !staleSet.has(id));
+
+          return next.length === prev.length ? prev : next;
+        });
+        setLoadingRevision((r) => r + 1);
+      })
+      .finally(() => {
+        unknownIds.forEach((id) => validatingRestoreIdsRef.current.delete(id));
+      });
+  }, [outline, pendingAutoLoadIds, loadViewChildrenBatch]);
+
   // Drop startup pending ids as soon as they are confirmed loaded.
   useEffect(() => {
     setPendingAutoLoadIds((prev) => {