apps/server/src/integrations/import/services/import.service.ts (1)

33-40: Constructor brace spacing is non-idiomatic; consider normalizing.
This is purely style, but ) { } sticks out vs typical Nest/TS formatting.

-  ) { }
+  ) {}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/client/src/pages/share-target/share-target.tsx (1)

89-97: Queries still fire with empty or invalid spaceId.

Both useGetRootSidebarPagesQuery and useGetSidebarPagesQuery are called with spaceId: selectedSpace || "", which triggers API calls with an empty string before a space is selected.

apps/server/src/integrations/import/services/import.service.ts (2)

90-118: Parent‑aware positioning and return value wiring look good; consider using pageTitle in log

With the scoping bug above fixed, the rest of importPage looks coherent:

• getNewPagePosition(spaceId, parentPageId) correctly passes through the parent ID so children get their own position sequence.
• insertPage now persists parentPageId: parentPageId || null, aligning the DB hierarchy with the new positioning logic.
• The method returns { id, slugId } | null, matching the earlier type mismatch feedback and current usage of createdPage.

Minor tweak you may want:

• The success log uses the raw title param ("${title}${fileExtension}..."), which may be empty/undefined when the title is derived from content or from fileName. Logging pageTitle instead would better reflect what the user actually sees.

Example adjustment:

-        this.logger.debug(
-          `Successfully imported "${title}${fileExtension}. ID: ${createdPage.id} - SlugId: ${createdPage.slugId}"`,
-        );
+        this.logger.debug(
+          `Successfully imported "${pageTitle}${fileExtension}". ID: ${createdPage.id} - SlugId: ${createdPage.slugId}`,
+        );

---

186-205: getNewPagePosition correctly scopes by parent; watch DB indexing

The updated getNewPagePosition:

• Filters by spaceId plus parentPageId when provided, or parentPageId IS NULL for root pages.
• Still orders by position (collation 'C') and takes the last row to generate a new jittered key.

This matches the hierarchical behavior you want for nested pages.

Operationally, ensure there’s an index that supports this query shape (e.g., on pages(spaceId, parentPageId, position) or similar) so that per‑parent inserts remain cheap as the table grows.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: lukasbach
Repo: docmost/docmost PR: 1457
File: apps/client/src/features/page/tree/components/space-tree.tsx:520-525
Timestamp: 2025-08-07T21:44:49.482Z
Learning: In the Docmost headless tree implementation (apps/client/src/features/page/tree/components/space-tree.tsx), the useEffect in the PageArrow component intentionally omits the dependency array. This allows isFolder() to run on subsequent renders as needed, since the item reference is stable and wouldn't trigger re-runs when required. This pattern is intentional for performance reasons in the tree component.

apps/server/src/integrations/import/services/import.service.ts (1)

78-86: Critical bug: Variable shadowing prevents page creation when title is empty.

The const destructuring on lines 81-82 creates block-scoped variables that shadow the outer let declarations. When title is null/empty, the outer contentTitle and prosemirrorJson remain undefined, causing if (prosemirrorJson) on line 90 to be false and silently skipping page creation.

Apply this diff to fix the shadowing:

  let contentTitle;
  let prosemirrorJson;
  if (title == null || title === "") {
-   const { title: contentTitle, prosemirrorJson } =
+   const extracted =
      this.extractTitleAndRemoveHeading(prosemirrorState);
+   contentTitle = extracted.title;
+   prosemirrorJson = extracted.prosemirrorJson;
  } else {
    contentTitle = title;
    prosemirrorJson = prosemirrorState;
  }

apps/server/src/integrations/import/services/import.service.ts (1)

114-116: Consider using pageTitle in debug log.

The log uses title (the optional parameter) which may be undefined. Using pageTitle (line 88) would provide more meaningful output.

       this.logger.debug(
-        `Successfully imported "${title}${fileExtension}. ID: ${createdPage.id} - SlugId: ${createdPage.slugId}"`,
+        `Successfully imported "${pageTitle}${fileExtension}". ID: ${createdPage.id} - SlugId: ${createdPage.slugId}`,
       );

Also note there's a missing closing quote before the period.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/client/src/pages/share-target/share-target.tsx (1)

88-98: Guard root pages query so it doesn’t fire with an empty spaceId

useGetRootSidebarPagesQuery({ spaceId: selectedSpace || "" }) will run with spaceId: "" before any space is chosen, and the hook itself has no enabled guard. That can trigger an API call with an invalid spaceId.

Consider either:

• Changing this call to only run when selectedSpace exists (e.g. pass undefined/null and add an enabled option inside useGetRootSidebarPagesQuery), or
• Reusing useGetSidebarPagesQuery for root listings, which already has an enabled guard on spaceId.

apps/client/src/pages/share-target/share-target.tsx (1)

359-455: Use isSearching for better search UX in the parent page picker

You maintain isSearching state but only show loaders based on isLoadingPages. During a search, the dropdown can briefly show “No pages found” while results are loading.

You can improve this by:

• Showing a loader when isSearching is true.
• Suppressing the “No pages found” state while a search is in progress.

For example:

-                                    {isLoadingPages && (
+                                    {(isLoadingPages || isSearching) && (
@@
-                                    {!isLoadingPages && pageItems.length === 0 && (
+                                    {!isLoadingPages && !isSearching && pageItems.length === 0 && (
                                         <Combobox.Empty>{t("No pages found")}</Combobox.Empty>
                                     )}

apps/server/src/integrations/import/services/import.service.ts (2)

92-101: Parent page validation + position lookup are sound; consider also validating workspace

Validating parentPageId via pageRepo.findById and checking parentPage.spaceId === spaceId prevents linking to a parent in another space, and passing parentPageId into getNewPagePosition ensures children are positioned within their parent’s sequence.

Optionally, you might also assert that the parent’s workspaceId matches the provided workspaceId (if not already guaranteed by data model) to harden cross-workspace isolation further.

---

102-114: Parent-child linkage in insertPage and logging look good, with a tiny log string nit

Setting parentPageId: parentPageId ?? null correctly normalizes the root vs child cases, and the rest of the payload (slugId, title, ydoc, textContent, etc.) is consistent with existing behavior.

Minor nit: the debug string has an extra quote after the filename:

`Successfully imported "${file.filename}. ID: ${createdPage.id} - SlugId: ${createdPage.slugId}"`
                    ^ extra quote before the dot

You probably meant:

`Successfully imported "${file.filename}". ID: ${createdPage.id} - SlugId: ${createdPage.slugId}`

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: lukasbach
Repo: docmost/docmost PR: 1457
File: apps/client/src/features/page/tree/components/space-tree.tsx:520-525
Timestamp: 2025-08-07T21:44:49.482Z
Learning: In the Docmost headless tree implementation (apps/client/src/features/page/tree/components/space-tree.tsx), the useEffect in the PageArrow component intentionally omits the dependency array. This allows isFolder() to run on subsequent renders as needed, since the item reference is stable and wouldn't trigger re-runs when required. This pattern is intentional for performance reasons in the tree component.

apps/client/src/pages/share-target/share-target.tsx (1)

89-91: Still firing root-pages query with empty spaceId.

This issue was flagged in a previous review but remains unresolved. useGetRootSidebarPagesQuery({ spaceId: selectedSpace || "" }) will execute with spaceId: "" when no space is selected, potentially causing an invalid API call.

The recommended fix is to add an enabled guard:

-    const { data: rootPagesData, isLoading: isLoadingRoot } = useGetRootSidebarPagesQuery({
-        spaceId: selectedSpace || "",
-    });
+    const { data: rootPagesData, isLoading: isLoadingRoot } = useGetRootSidebarPagesQuery(
+        { spaceId: selectedSpace || "" },
+        { enabled: !!selectedSpace }
+    );

Alternatively, modify the useGetRootSidebarPagesQuery hook definition to include an internal enabled: !!data.spaceId guard.

apps/client/src/pages/share-target/share-target.tsx (3)

100-124: Minor: search results not cleared when search becomes empty.

When debouncedSearchValue becomes empty or falsy, the effect doesn't execute, leaving old searchResults in state. While line 305 prevents these stale results from being displayed, clearing them would improve state hygiene.

Optional refactor:

     useEffect(() => {
+        if (!debouncedSearchValue || !selectedSpace) {
+            setSearchResults([]);
+            return;
+        }
+
         const fetchSearchResults = async () => {
-            if (debouncedSearchValue && selectedSpace) {
                 const trimmed = debouncedSearchValue.trim();
                 if (trimmed && selectedSpace) {
                     setIsSearching(true);
                     try {
                         const results = await searchPage({
                             query: trimmed,
                             spaceId: selectedSpace,
                         });
                         setSearchResults(results);
                     } catch (error) {
                         console.error("Search failed", error);
                     } finally {
                         setIsSearching(false);
                     }
                 } else {
                     setSearchResults([]);
                 }
-            }
         };
 
         fetchSearchResults();
     }, [debouncedSearchValue, selectedSpace]);

Also note: the selectedSpace check on line 104 is redundant (already checked on line 102).

---

174-178: Use strict equality operators.

Lines 174 and 177 use loose equality (==) instead of strict equality (===). While functionally equivalent here, strict equality is a best practice in JavaScript/TypeScript.

-                    } else if (url == null || url.trim() == '') {
+                    } else if (url == null || url.trim() === '') {
                         return; // Abort
                     }
-                } else if (url == null || url.trim() == '') {
+                } else if (url == null || url.trim() === '') {
                     return; // Abort
                 }

---

223-268: Optional: capture selectedSpace before async operations for consistency.

While double-submit prevention is correctly implemented, capturing selectedSpace in a local variable at the start of handleImport would guard against the theoretical race where the user changes the selected space while the import request is in flight.

     const handleImport = async () => {
         if (!selectedSpace || !sharedData || isImporting) return;
+        const spaceId = selectedSpace;
 
         setIsImporting(true);
         try {
             const { title, text } = sharedData;
 
             const safeTitle = (title || "Shared page")
                 .replace(/[\\\/:*?"<>|]+/g, "-")
                 .trim()
                 .slice(0, 120);
             const blob = new Blob([text], { type: "text/markdown" });
             const formData = new FormData();
             // Page import uses the filename as the title
-            formData.append("spaceId", selectedSpace);
+            formData.append("spaceId", spaceId);
             formData.append("title", title);
             formData.append("file", blob, `${safeTitle}.md`);
 
             if (selectedParentPage) {
                 formData.append("parentPageId", selectedParentPage);
             }
 
             const response = await api.post("/pages/import", formData);
 
             const newPage = response.data;
 
             notifications.show({
                 message: t("Page created successfully"),
             });
 
             if (newPage?.slugId) {
-                navigate(`/s/${selectedSpace}/p/${newPage.slugId}`, { replace: true });
+                navigate(`/s/${spaceId}/p/${newPage.slugId}`, { replace: true });
             } else {
                 navigate("/home", { replace: true });
             }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: lukasbach
Repo: docmost/docmost PR: 1457
File: apps/client/src/features/page/tree/components/space-tree.tsx:520-525
Timestamp: 2025-08-07T21:44:49.482Z
Learning: In the Docmost headless tree implementation (apps/client/src/features/page/tree/components/space-tree.tsx), the useEffect in the PageArrow component intentionally omits the dependency array. This allows isFolder() to run on subsequent renders as needed, since the item reference is stable and wouldn't trigger re-runs when required. This pattern is intentional for performance reasons in the tree component.