Add SurfSense docs to documents table

surfsense_web/app/dashboard/[search_space_id]/documents/(manage)/components/DocumentsFilters.tsx

@@ -47,7 +47,7 @@ export function DocumentsFilters({
 	columnVisibility,
 	onToggleColumn,
 }: {
-	typeCounts: Record<DocumentTypeEnum, number>;
+	typeCounts: Partial<Record<DocumentTypeEnum, number>>;
 	selectedIds: Set<number>;
 	onSearch: (v: string) => void;
 	searchValue: string;

surfsense_web/app/dashboard/[search_space_id]/documents/(manage)/components/DocumentsTableShell.tsx

@@ -79,17 +79,25 @@ export function DocumentsTableShell({
 		[documents, sortKey, sortDesc]
 	);
 
-	const allSelectedOnPage = sorted.length > 0 && sorted.every((d) => selectedIds.has(d.id));
-	const someSelectedOnPage = sorted.some((d) => selectedIds.has(d.id)) && !allSelectedOnPage;
+	// Filter out SURFSENSE_DOCS for selection purposes
+	const selectableDocs = React.useMemo(
+		() => sorted.filter((d) => d.document_type !== "SURFSENSE_DOCS"),
+		[sorted]
+	);
+
+	const allSelectedOnPage =
+		selectableDocs.length > 0 && selectableDocs.every((d) => selectedIds.has(d.id));
+	const someSelectedOnPage =
+		selectableDocs.some((d) => selectedIds.has(d.id)) && !allSelectedOnPage;
 
 	const toggleAll = (checked: boolean) => {
 		const next = new Set(selectedIds);
 		if (checked)
-			sorted.forEach((d) => {
+			selectableDocs.forEach((d) => {
 				next.add(d.id);
 			});
 		else
-			sorted.forEach((d) => {
+			selectableDocs.forEach((d) => {
 				next.delete(d.id);
 			});
 		setSelectedIds(next);
@@ -230,9 +238,10 @@ export function DocumentsTableShell({
 									const icon = getDocumentTypeIcon(doc.document_type);
 									const title = doc.title;
 									const truncatedTitle = title.length > 30 ? `${title.slice(0, 30)}...` : title;
+									const isSurfsenseDoc = doc.document_type === "SURFSENSE_DOCS";
 									return (
 										<motion.tr
-											key={doc.id}
+											key={`${doc.document_type}-${doc.id}`}
 											initial={{ opacity: 0, y: 10 }}
 											animate={{
 												opacity: 1,
@@ -249,8 +258,9 @@ export function DocumentsTableShell({
 										>
 											<TableCell className="px-4 py-3">
 												<Checkbox
-													checked={selectedIds.has(doc.id)}
-													onCheckedChange={(v) => toggleOne(doc.id, !!v)}
+													checked={selectedIds.has(doc.id) && !isSurfsenseDoc}
+													onCheckedChange={(v) => !isSurfsenseDoc && toggleOne(doc.id, !!v)}
+													disabled={isSurfsenseDoc}
 													aria-label="Select row"
 												/>
 											</TableCell>

surfsense_web/app/dashboard/[search_space_id]/documents/(manage)/components/RowActions.tsx

@@ -28,6 +28,9 @@ import type { Document } from "./types";
 // Only FILE and NOTE document types can be edited
 const EDITABLE_DOCUMENT_TYPES = ["FILE", "NOTE"] as const;
 
+// SURFSENSE_DOCS are system-managed and cannot be deleted
+const NON_DELETABLE_DOCUMENT_TYPES = ["SURFSENSE_DOCS"] as const;
+
 export function RowActions({
 	document,
 	deleteDocument,
@@ -48,6 +51,10 @@ export function RowActions({
 		document.document_type as (typeof EDITABLE_DOCUMENT_TYPES)[number]
 	);
 
+	const isDeletable = !NON_DELETABLE_DOCUMENT_TYPES.includes(
+		document.document_type as (typeof NON_DELETABLE_DOCUMENT_TYPES)[number]
+	);
+
 	const handleDelete = async () => {
 		setIsDeleting(true);
 		try {
@@ -120,29 +127,31 @@ export function RowActions({
 					</TooltipContent>
 				</Tooltip>
 
-				<Tooltip>
-					<TooltipTrigger asChild>
-						<motion.div
-							whileHover={{ scale: 1.1 }}
-							whileTap={{ scale: 0.95 }}
-							transition={{ type: "spring", stiffness: 400, damping: 17 }}
-						>
-							<Button
-								variant="ghost"
-								size="icon"
-								className="h-8 w-8 text-muted-foreground hover:text-destructive hover:bg-destructive/10"
-								onClick={() => setIsDeleteOpen(true)}
-								disabled={isDeleting}
+				{isDeletable && (
+					<Tooltip>
+						<TooltipTrigger asChild>
+							<motion.div
+								whileHover={{ scale: 1.1 }}
+								whileTap={{ scale: 0.95 }}
+								transition={{ type: "spring", stiffness: 400, damping: 17 }}
 							>
-								<Trash2 className="h-4 w-4" />
-								<span className="sr-only">Delete</span>
-							</Button>
-						</motion.div>
-					</TooltipTrigger>
-					<TooltipContent side="top">
-						<p>Delete</p>
-					</TooltipContent>
-				</Tooltip>
+								<Button
+									variant="ghost"
+									size="icon"
+									className="h-8 w-8 text-muted-foreground hover:text-destructive hover:bg-destructive/10"
+									onClick={() => setIsDeleteOpen(true)}
+									disabled={isDeleting}
+								>
+									<Trash2 className="h-4 w-4" />
+									<span className="sr-only">Delete</span>
+								</Button>
+							</motion.div>
+						</TooltipTrigger>
+						<TooltipContent side="top">
+							<p>Delete</p>
+						</TooltipContent>
+					</Tooltip>
+				)}
 			</div>
 
 			{/* Mobile Actions Dropdown */}
@@ -165,13 +174,15 @@ export function RowActions({
 							<FileText className="mr-2 h-4 w-4" />
 							<span>Metadata</span>
 						</DropdownMenuItem>
-						<DropdownMenuItem
-							onClick={() => setIsDeleteOpen(true)}
-							className="text-destructive focus:text-destructive"
-						>
-							<Trash2 className="mr-2 h-4 w-4" />
-							<span>Delete</span>
-						</DropdownMenuItem>
+						{isDeletable && (
+							<DropdownMenuItem
+								onClick={() => setIsDeleteOpen(true)}
+								className="text-destructive focus:text-destructive"
+							>
+								<Trash2 className="mr-2 h-4 w-4" />
+								<span>Delete</span>
+							</DropdownMenuItem>
+						)}
 					</DropdownMenuContent>
 				</DropdownMenu>
 			</div>

surfsense_web/app/dashboard/[search_space_id]/documents/(manage)/page.tsx

@@ -19,7 +19,7 @@ import { DocumentsFilters } from "./components/DocumentsFilters";
 import { DocumentsTableShell, type SortKey } from "./components/DocumentsTableShell";
 import { PaginationControls } from "./components/PaginationControls";
 import { ProcessingIndicator } from "./components/ProcessingIndicator";
-import type { ColumnVisibility } from "./components/types";
+import type { ColumnVisibility, Document } from "./components/types";
 
 function useDebounced<T>(value: T, delay = 250) {
 	const [debounced, setDebounced] = useState(value);
@@ -50,33 +50,43 @@ export default function DocumentsTable() {
 	const [sortKey, setSortKey] = useState<SortKey>("title");
 	const [sortDesc, setSortDesc] = useState(false);
 	const [selectedIds, setSelectedIds] = useState<Set<number>>(new Set());
-	const { data: typeCounts } = useAtomValue(documentTypeCountsAtom);
+	const { data: rawTypeCounts } = useAtomValue(documentTypeCountsAtom);
 	const { mutateAsync: deleteDocumentMutation } = useAtomValue(deleteDocumentMutationAtom);
 
-	// Build query parameters for fetching documents
+	// Filter out SURFSENSE_DOCS from active types for regular documents API
+	const regularDocumentTypes = useMemo(
+		() => activeTypes.filter((t) => t !== "SURFSENSE_DOCS"),
+		[activeTypes]
+	);
+
+	// Check if only SURFSENSE_DOCS is selected (skip regular docs query)
+	const onlySurfsenseDocsSelected =
+		activeTypes.length === 1 && activeTypes[0] === "SURFSENSE_DOCS";
+
+	// Build query parameters for fetching documents (excluding SURFSENSE_DOCS type)
 	const queryParams = useMemo(
 		() => ({
 			search_space_id: searchSpaceId,
 			page: pageIndex,
 			page_size: pageSize,
-			...(activeTypes.length > 0 && { document_types: activeTypes }),
+			...(regularDocumentTypes.length > 0 && { document_types: regularDocumentTypes }),
 		}),
-		[searchSpaceId, pageIndex, pageSize, activeTypes]
+		[searchSpaceId, pageIndex, pageSize, regularDocumentTypes]
 	);
 
-	// Build search query parameters
+	// Build search query parameters (excluding SURFSENSE_DOCS type)
 	const searchQueryParams = useMemo(
 		() => ({
 			search_space_id: searchSpaceId,
 			page: pageIndex,
 			page_size: pageSize,
 			title: debouncedSearch.trim(),
-			...(activeTypes.length > 0 && { document_types: activeTypes }),
+			...(regularDocumentTypes.length > 0 && { document_types: regularDocumentTypes }),
 		}),
-		[searchSpaceId, pageIndex, pageSize, activeTypes, debouncedSearch]
+		[searchSpaceId, pageIndex, pageSize, regularDocumentTypes, debouncedSearch]
 	);
 
-	// Use query for fetching documents
+	// Use query for fetching documents (disabled when only SURFSENSE_DOCS is selected)
 	const {
 		data: documentsResponse,
 		isLoading: isDocumentsLoading,
@@ -86,10 +96,10 @@ export default function DocumentsTable() {
 		queryKey: cacheKeys.documents.globalQueryParams(queryParams),
 		queryFn: () => documentsApiService.getDocuments({ queryParams }),
 		staleTime: 3 * 60 * 1000, // 3 minutes
-		enabled: !!searchSpaceId && !debouncedSearch.trim(),
+		enabled: !!searchSpaceId && !debouncedSearch.trim() && !onlySurfsenseDocsSelected,
 	});
 
-	// Use query for searching documents
+	// Use query for searching documents (disabled when only SURFSENSE_DOCS is selected)
 	const {
 		data: searchResponse,
 		isLoading: isSearchLoading,
@@ -99,16 +109,109 @@ export default function DocumentsTable() {
 		queryKey: cacheKeys.documents.globalQueryParams(searchQueryParams),
 		queryFn: () => documentsApiService.searchDocuments({ queryParams: searchQueryParams }),
 		staleTime: 3 * 60 * 1000, // 3 minutes
-		enabled: !!searchSpaceId && !!debouncedSearch.trim(),
+		enabled: !!searchSpaceId && !!debouncedSearch.trim() && !onlySurfsenseDocsSelected,
 	});
 
+	// Determine if we should show SurfSense docs (when no type filter or SURFSENSE_DOCS is selected)
+	const showSurfsenseDocs =
+		activeTypes.length === 0 || activeTypes.includes("SURFSENSE_DOCS" as DocumentTypeEnum);
+
+	// Use query for fetching SurfSense docs
+	const {
+		data: surfsenseDocsResponse,
+		isLoading: isSurfsenseDocsLoading,
+		refetch: refetchSurfsenseDocs,
+	} = useQuery({
+		queryKey: ["surfsense-docs", debouncedSearch, pageIndex, pageSize],
+		queryFn: () =>
+			documentsApiService.getSurfsenseDocs({
+				page: pageIndex,
+				page_size: pageSize,
+				title: debouncedSearch.trim() || undefined,
+			}),
+		staleTime: 3 * 60 * 1000, // 3 minutes
+		enabled: showSurfsenseDocs,
+	});
+
+	// Transform SurfSense docs to match the Document type
+	const surfsenseDocsAsDocuments: Document[] = useMemo(() => {
+		if (!surfsenseDocsResponse?.items) return [];
+		return surfsenseDocsResponse.items.map((doc) => ({
+			id: doc.id,
+			title: doc.title,
+			document_type: "SURFSENSE_DOCS",
+			document_metadata: { source: doc.source },
+			content: doc.content,
+			created_at: doc.created_at || doc.updated_at || new Date().toISOString(),
+			search_space_id: -1, // Special value for global docs
+		}));
+	}, [surfsenseDocsResponse]);
+
+	// Merge type counts with SURFSENSE_DOCS count
+	const typeCounts = useMemo(() => {
+		const counts = { ...(rawTypeCounts || {}) };
+		if (surfsenseDocsResponse?.total) {
+			counts.SURFSENSE_DOCS = surfsenseDocsResponse.total;
+		}
+		return counts;
+	}, [rawTypeCounts, surfsenseDocsResponse?.total]);
+
 	// Extract documents and total based on search state
-	const documents = debouncedSearch.trim()
+	const regularDocuments = debouncedSearch.trim()
 		? searchResponse?.items || []
 		: documentsResponse?.items || [];
-	const total = debouncedSearch.trim() ? searchResponse?.total || 0 : documentsResponse?.total || 0;
-	const loading = debouncedSearch.trim() ? isSearchLoading : isDocumentsLoading;
-	const error = debouncedSearch.trim() ? searchError : documentsError;
+	const regularTotal = debouncedSearch.trim()
+		? searchResponse?.total || 0
+		: documentsResponse?.total || 0;
+
+	// Merge regular documents with SurfSense docs
+	const documents = useMemo(() => {
+		// If filtering by type and not including SURFSENSE_DOCS, only show regular docs
+		if (activeTypes.length > 0 && !activeTypes.includes("SURFSENSE_DOCS" as DocumentTypeEnum)) {
+			return regularDocuments;
+		}
+		// If filtering only by SURFSENSE_DOCS, only show surfsense docs
+		if (activeTypes.length === 1 && activeTypes[0] === "SURFSENSE_DOCS") {
+			return surfsenseDocsAsDocuments;
+		}
+		// Otherwise, merge both (surfsense docs first)
+		return [...surfsenseDocsAsDocuments, ...regularDocuments];
+	}, [regularDocuments, surfsenseDocsAsDocuments, activeTypes]);
+
+	const total = useMemo(() => {
+		if (activeTypes.length > 0 && !activeTypes.includes("SURFSENSE_DOCS" as DocumentTypeEnum)) {
+			return regularTotal;
+		}
+		if (activeTypes.length === 1 && activeTypes[0] === "SURFSENSE_DOCS") {
+			return surfsenseDocsResponse?.total || 0;
+		}
+		return regularTotal + (surfsenseDocsResponse?.total || 0);
+	}, [regularTotal, surfsenseDocsResponse?.total, activeTypes]);
+
+	const loading = useMemo(() => {
+		// If only SURFSENSE_DOCS selected, only check surfsense loading
+		if (onlySurfsenseDocsSelected) {
+			return isSurfsenseDocsLoading;
+		}
+		// Otherwise check both regular docs and surfsense docs loading
+		const regularLoading = debouncedSearch.trim() ? isSearchLoading : isDocumentsLoading;
+		return regularLoading || (showSurfsenseDocs && isSurfsenseDocsLoading);
+	}, [
+		onlySurfsenseDocsSelected,
+		isSurfsenseDocsLoading,
+		debouncedSearch,
+		isSearchLoading,
+		isDocumentsLoading,
+		showSurfsenseDocs,
+	]);
+
+	const error = useMemo(() => {
+		// If only SURFSENSE_DOCS selected, no regular docs errors
+		if (onlySurfsenseDocsSelected) {
+			return null;
+		}
+		return debouncedSearch.trim() ? searchError : documentsError;
+	}, [onlySurfsenseDocsSelected, debouncedSearch, searchError, documentsError]);
 
 	// Display server-filtered results directly
 	const displayDocs = documents || [];
@@ -131,16 +234,24 @@ export default function DocumentsTable() {
 		if (isRefreshing) return;
 		setIsRefreshing(true);
 		try {
-			if (debouncedSearch.trim()) {
-				await refetchSearch();
-			} else {
-				await refetchDocuments();
+			const refetchPromises: Promise<unknown>[] = [];
+			// Only refetch regular documents if not in "only surfsense docs" mode
+			if (!onlySurfsenseDocsSelected) {
+				if (debouncedSearch.trim()) {
+					refetchPromises.push(refetchSearch());
+				} else {
+					refetchPromises.push(refetchDocuments());
+				}
 			}
+			if (showSurfsenseDocs) {
+				refetchPromises.push(refetchSurfsenseDocs());
+			}
+			await Promise.all(refetchPromises);
 			toast.success(t("refresh_success") || "Documents refreshed");
 		} finally {
 			setIsRefreshing(false);
 		}
-	}, [debouncedSearch, refetchSearch, refetchDocuments, t, isRefreshing]);
+	}, [debouncedSearch, refetchSearch, refetchDocuments, refetchSurfsenseDocs, showSurfsenseDocs, onlySurfsenseDocsSelected, t, isRefreshing]);
 
 	// Set up smart polling for active tasks - only polls when tasks are in progress
 	const { summary } = useLogsSummary(searchSpaceId, 24, {