Admin data room search

components/datarooms/dataroom-search-results.tsx

@@ -0,0 +1,160 @@
+import Link from "next/link";
+import { useRouter } from "next/router";
+
+import { TeamContextType } from "@/context/team-context";
+import { ChevronRight, FileIcon, FolderIcon } from "lucide-react";
+
+import {
+  DataroomFolderDocumentWithPath,
+  DataroomFolderWithCountAndPath,
+} from "@/lib/swr/use-dataroom";
+import { safeSlugify } from "@/lib/utils";
+
+import DataroomDocumentCard from "@/components/datarooms/dataroom-document-card";
+import FolderCard from "@/components/documents/folder-card";
+
+function FolderPathBreadcrumb({
+  folderPath,
+  dataroomId,
+}: {
+  folderPath: string[];
+  dataroomId: string;
+}) {
+  const router = useRouter();
+  const { id } = router.query as { id: string };
+
+  const buildLink = (index: number) => {
+    if (index < 0) return `/datarooms/${id}/documents`;
+    const slugs = folderPath.slice(0, index + 1).map(safeSlugify);
+    return `/datarooms/${id}/documents/${slugs.join("/")}`;
+  };
+
+  return (
+    <div className="mt-1 flex flex-wrap items-center gap-x-1 text-xs leading-5 text-muted-foreground">
+      <p className="flex items-center gap-x-1">
+        <FolderIcon className="h-3 w-3" />
+        <Link
+          href={`/datarooms/${id}/documents`}
+          onClick={(e) => e.stopPropagation()}
+          className="relative z-10 hover:underline"
+        >
+          Root
+        </Link>
+      </p>
+      {folderPath.map((name, index) => (
+        <p key={index} className="flex items-center gap-x-1">
+          <ChevronRight className="h-3 w-3" />
+          <FolderIcon className="h-3 w-3" />
+          <Link
+            href={buildLink(index)}
+            onClick={(e) => e.stopPropagation()}
+            className="relative z-10 hover:underline"
+          >
+            {name}
+          </Link>
+        </p>
+      ))}
+    </div>
+  );
+}
+
+export function DataroomSearchResults({
+  documents,
+  folders,
+  teamInfo,
+  dataroomId,
+  searchQuery,
+}: {
+  documents: DataroomFolderDocumentWithPath[];
+  folders: DataroomFolderWithCountAndPath[];
+  teamInfo: TeamContextType | null;
+  dataroomId: string;
+  searchQuery: string;
+}) {
+  const totalResults = documents.length + folders.length;
+
+  return (
+    <div className="space-y-4">
+      <div className="flex items-center gap-x-2 text-sm text-muted-foreground">
+        <span>
+          Search results for &quot;{searchQuery}&quot;
+        </span>
+        <span className="text-xs">
+          ({totalResults} result{totalResults !== 1 ? "s" : ""})
+        </span>
+      </div>
+
+      {totalResults === 0 ? (
+        <div className="flex flex-col items-center justify-center rounded-lg border border-dashed py-12">
+          <p className="text-sm text-muted-foreground">
+            No documents or folders found matching &quot;{searchQuery}&quot;
+          </p>
+        </div>
+      ) : (
+        <ul role="list" className="space-y-4">
+          {folders.length > 0 && (
+            <>
+              <li className="flex items-center gap-x-1 text-sm text-muted-foreground">
+                <FolderIcon className="h-4 w-4" />
+                <span>
+                  {folders.length} folder{folders.length !== 1 ? "s" : ""}
+                </span>
+              </li>
+              {folders.map((folder) => (
+                <li key={`folder-${folder.id}`}>
+                  <div>
+                    <FolderCard
+                      folder={folder}
+                      teamInfo={teamInfo}
+                      isDataroom={true}
+                      dataroomId={dataroomId}
+                    />
+                    {folder.folderPath.length > 0 && (
+                      <div className="ml-4 mt-1">
+                        <FolderPathBreadcrumb
+                          folderPath={folder.folderPath}
+                          dataroomId={dataroomId}
+                        />
+                      </div>
+                    )}
+                  </div>
+                </li>
+              ))}
+            </>
+          )}
+
+          {documents.length > 0 && (
+            <>
+              <li className="flex items-center gap-x-1 text-sm text-muted-foreground">
+                <FileIcon className="h-4 w-4" />
+                <span>
+                  {documents.length} document
+                  {documents.length !== 1 ? "s" : ""}
+                </span>
+              </li>
+              {documents.map((doc) => (
+                <li key={`document-${doc.id}`}>
+                  <div>
+                    <DataroomDocumentCard
+                      document={doc}
+                      teamInfo={teamInfo}
+                      dataroomId={dataroomId}
+                    />
+                    {doc.folderPath.length > 0 && (
+                      <div className="ml-4 mt-1">
+                        <FolderPathBreadcrumb
+                          folderPath={doc.folderPath}
+                          dataroomId={dataroomId}
+                        />
+                      </div>
+                    )}
+                  </div>
+                </li>
+              ))}
+            </>
+          )}
+        </ul>
+      )}
+    </div>
+  );
+}

lib/swr/use-dataroom.ts

@@ -443,3 +443,43 @@ export function useDataroomVisitHistory({
     error,
   };
 }
+
+export type DataroomFolderWithCountAndPath = DataroomFolderWithCount & {
+  folderPath: string[];
+};
+
+export type DataroomFolderDocumentWithPath = DataroomFolderDocument & {
+  folderPath: string[];
+};
+
+export function useDataroomSearch({ query }: { query: string }) {
+  const router = useRouter();
+  const { id } = router.query as { id: string };
+  const teamInfo = useTeam();
+  const teamId = teamInfo?.currentTeam?.id;
+
+  const { data, error } = useSWR<{
+    documents: DataroomFolderDocumentWithPath[];
+    folders: DataroomFolderWithCountAndPath[];
+  }>(
+    teamId &&
+      id &&
+      query &&
+      query.trim().length > 0 &&
+      `/api/teams/${teamId}/datarooms/${id}/search?query=${encodeURIComponent(query.trim())}`,
+    fetcher,
+    {
+      revalidateOnFocus: false,
+      dedupingInterval: 10000,
+    },
+  );
+
+  const isLoading = query.trim().length > 0 && !data && !error;
+
+  return {
+    documents: data?.documents || [],
+    folders: data?.folders || [],
+    isLoading,
+    error,
+  };
+}

pages/api/teams/[teamId]/datarooms/[id]/search.ts

@@ -0,0 +1,173 @@
+import { NextApiRequest, NextApiResponse } from "next";
+
+import { authOptions } from "@/pages/api/auth/[...nextauth]";
+import { getServerSession } from "next-auth/next";
+
+import prisma from "@/lib/prisma";
+import { CustomUser } from "@/lib/types";
+
+export default async function handle(
+  req: NextApiRequest,
+  res: NextApiResponse,
+) {
+  if (req.method !== "GET") {
+    res.setHeader("Allow", ["GET"]);
+    return res.status(405).end(`Method ${req.method} Not Allowed`);
+  }
+
+  const session = await getServerSession(req, res, authOptions);
+  if (!session) {
+    return res.status(401).end("Unauthorized");
+  }
+
+  const userId = (session.user as CustomUser).id;
+  const {
+    teamId,
+    id: dataroomId,
+    query,
+  } = req.query as {
+    teamId: string;
+    id: string;
+    query?: string;
+  };
+
+  if (!query || query.trim().length === 0) {
+    return res.status(200).json({ documents: [], folders: [] });
+  }
+
+  try {
+    const team = await prisma.team.findUnique({
+      where: {
+        id: teamId,
+        users: {
+          some: { userId },
+        },
+      },
+    });
+
+    if (!team) {
+      return res.status(401).end("Unauthorized");
+    }
+
+    const [documents, folders] = await Promise.all([
+      prisma.dataroomDocument.findMany({
+        where: {
+          dataroomId,
+          document: {
+            name: {
+              contains: query.trim(),
+              mode: "insensitive",
+            },
+          },
+        },
+        orderBy: [
+          { orderIndex: "asc" },
+          { document: { name: "asc" } },
+        ],
+        select: {
+          id: true,
+          dataroomId: true,
+          folderId: true,
+          orderIndex: true,
+          hierarchicalIndex: true,
+          createdAt: true,
+          updatedAt: true,
+          document: {
+            select: {
+              id: true,
+              name: true,
+              type: true,
+              advancedExcelEnabled: true,
+              versions: {
+                select: { id: true, hasPages: true },
+              },
+              isExternalUpload: true,
+              _count: {
+                select: {
+                  views: { where: { dataroomId } },
+                  versions: true,
+                },
+              },
+            },
+          },
+        },
+      }),
+
+      prisma.dataroomFolder.findMany({
+        where: {
+          dataroomId,
+          name: {
+            contains: query.trim(),
+            mode: "insensitive",
+          },
+        },
+        orderBy: [{ orderIndex: "asc" }, { name: "asc" }],
+        select: {
+          id: true,
+          name: true,
+          path: true,
+          parentId: true,
+          dataroomId: true,
+          orderIndex: true,
+          hierarchicalIndex: true,
+          icon: true,
+          color: true,
+          createdAt: true,
+          updatedAt: true,
+          _count: {
+            select: { documents: true, childFolders: true },
+          },
+        },
+      }),
+    ]);
+
+    // Build breadcrumb paths for documents that are in folders
+    const folderIds = [
+      ...new Set(documents.filter((d) => d.folderId).map((d) => d.folderId!)),
+    ];
+
+    const allFoldersInDataroom =
+      folderIds.length > 0
+        ? await prisma.dataroomFolder.findMany({
+            where: { dataroomId },
+            select: { id: true, name: true, path: true, parentId: true },
+          })
+        : [];
+
+    const folderMap = new Map(
+      allFoldersInDataroom.map((f) => [f.id, f]),
+    );
+
+    const buildBreadcrumb = (folderId: string): string[] => {
+      const names: string[] = [];
+      let currentId: string | null = folderId;
+      while (currentId) {
+        const folder = folderMap.get(currentId);
+        if (!folder) break;
+        names.unshift(folder.name);
+        currentId = folder.parentId;
+      }
+      return names;
+    };
+
+    const documentsWithPath = documents.map((doc) => ({
+      ...doc,
+      folderPath: doc.folderId ? buildBreadcrumb(doc.folderId) : [],
+    }));
+
+    const foldersWithPath = folders.map((folder) => ({
+      ...folder,
+      folderPath: folder.parentId ? buildBreadcrumb(folder.parentId) : [],
+    }));
+
+    return res.status(200).json({
+      documents: documentsWithPath,
+      folders: foldersWithPath,
+    });
+  } catch (error) {
+    console.error("Request error", error);
+    return res
+      .status(500)
+      .json({ error: "Error searching dataroom" });
+  }
+}