Skip to content

⭐️⭐️⭐️ Open-source, self-hosted alternative to Linear and Plane. Project management and issue tracking where teams and AI agents work side by side to plan and ship products.

6.8 KB
Raw Blame
'use client';

import { useEffect } from 'react';
import { useParams, useRouter } from 'next/navigation';
import { toast } from 'sonner';
import { useShellRoute } from '@/hooks/useShellRoute';
import { useShell } from '@/context/shellContext';
import { usePermissions } from '@/hooks/usePermissions';
import { useLiveRefresh } from '@/hooks/useLiveRefresh';
import { revScope } from '@/utils/revScopes';
import { qk } from '@/services/queryKeys';
import { documentsPath, documentPath } from '@/utils/paths';
import { Skeleton } from '@/components/ui/skeleton';
import { ApiError } from '@/lib/api/core/client';
import {
  useCreateDocument,
  useDocumentQuery,
  useDocumentsQuery,
} from './services/documents.service';
import DocumentView from './components/DocumentView';
import DocumentsIndex from './components/DocumentsIndex';
import { importedMarkdownJson, markdownTitle } from './utils/documentImport';
import { documentBelongsToTab, type DocumentListTab } from './utils/documentList';
import { useDebouncedValue } from '@/hooks/useDebouncedValue';
import { titlePath, useDocumentTitle } from '@/hooks/useDocumentTitle';
import { useDocumentNavigation, useRecentDocuments } from '@/hooks/useDocumentNavigation';
import { useTranslations } from 'next-intl';

const listDefaults: { search: string; tab: DocumentListTab } = { search: '', tab: 'public' };

export default function DocumentsPage() {
  const { project } = useShell();
  const params = useParams<{ documentId?: string }>();
  const router = useRouter();
  const t = useTranslations('documents');
  const { can } = usePermissions();
  const projectKey = useShellRoute().projectKey ?? '';
  const routeId = params.documentId ? Number(params.documentId) : null;
  const documentId = routeId && Number.isFinite(routeId) ? routeId : null;
  const [navigation, setNavigation] = useDocumentNavigation(projectKey, 'list', listDefaults);
  const search = typeof navigation.search === 'string' ? navigation.search : '';
  const listTab = ['public', 'private', 'favorites', 'archived'].includes(navigation.tab)
    ? navigation.tab
    : 'public';
  const setSearch = (search: string) => setNavigation((previous) => ({ ...previous, search }));
  const setListTab = (tab: DocumentListTab) => setNavigation((previous) => ({ ...previous, tab }));
  const deferredSearch = useDebouncedValue(search.trim(), 250);
  const { visit } = useRecentDocuments(projectKey);
  useEffect(() => {
    if (documentId !== null) visit(documentId);
  }, [documentId, visit]);
  const activeDocumentsQuery = useDocumentsQuery(
    projectKey,
    deferredSearch,
    false,
    documentId === null && listTab !== 'archived',
  );
  const archivedDocumentsQuery = useDocumentsQuery(
    projectKey,
    deferredSearch,
    true,
    documentId === null && listTab === 'archived',
  );
  const visibleDocumentsQuery =
    listTab === 'archived' ? archivedDocumentsQuery : activeDocumentsQuery;
  const filteredDocuments = (visibleDocumentsQuery.data ?? []).filter((document) =>
    documentBelongsToTab(document, listTab),
  );
  const visibleIds = new Set(filteredDocuments.map((document) => document.id));
  const reorderSafe = filteredDocuments.every(
    (document) => document.parentId === null || visibleIds.has(document.parentId),
  );
  const visibleDocuments = filteredDocuments.map((document) =>
    document.parentId !== null && !visibleIds.has(document.parentId)
      ? { ...document, parentId: null }
      : document,
  );
  const documentQuery = useDocumentQuery(projectKey, documentId);
  const documentTitle =
    !documentQuery.isError &&
    documentQuery.data &&
    (documentQuery.data.title.trim() || t('untitled'));
  useDocumentTitle(titlePath(project?.project.name, documentTitle));
  const createDocument = useCreateDocument(projectKey);
  const canRead = can('documents', 'read');
  const canCreate = can('documents', 'create');
  const canEdit = can('documents', 'edit');

  useLiveRefresh({
    scope: project ? revScope.documents(project.project.id) : null,
    targets: [qk.documentListsForProject(projectKey)],
  });

  useEffect(() => {
    if (documentQuery.error instanceof ApiError && documentQuery.error.status === 404) {
      router.replace(documentsPath(projectKey));
    }
  }, [documentQuery.error, projectKey, router]);

  if (!project) {
    return (
      <div className="flex flex-1 gap-0 overflow-hidden">
        <Skeleton className="m-4 w-72" />
        <Skeleton className="m-4 flex-1" />
      </div>
    );
  }

  if (!canRead) {
    return (
      <div className="flex flex-1 items-center justify-center px-4 text-center text-sm text-muted-foreground">
        {t('noAccess')}
      </div>
    );
  }

  const create = async (parentId: number | null, isPrivate: boolean) => {
    try {
      setSearch('');
      const newDocument = await createDocument.mutateAsync({ parentId, isPrivate });
      router.push(documentPath(projectKey, newDocument.id));
    } catch {
      // Mutation errors are reported by the shared query client.
    }
  };

  const upload = async (file: File) => {
    let markdown: string;
    try {
      markdown = (await file.text()).replace(/^\uFEFF/, '');
    } catch {
      toast.error(t('markdownReadFailed'));
      return;
    }
    const contentJson = importedMarkdownJson(markdown);
    if (!contentJson) {
      toast.error(t('markdownTooLarge'));
      return;
    }
    try {
      setSearch('');
      const newDocument = await createDocument.mutateAsync({
        title: markdownTitle(file.name),
        content: markdown,
        contentJson,
        isPrivate: listTab === 'private',
      });
      router.push(documentPath(projectKey, newDocument.id));
    } catch {
      // Mutation errors are reported by the shared query client.
    }
  };

  if (documentId === null) {
    return (
      <DocumentsIndex
        projectKey={projectKey}
        documents={visibleDocuments}
        tab={listTab}
        search={search}
        searching={deferredSearch.length > 0}
        loading={visibleDocumentsQuery.isLoading}
        failed={visibleDocumentsQuery.isError}
        canCreate={canCreate}
        canEdit={canEdit}
        authorNames={Object.fromEntries(
          project.assignees.map((candidate) => [candidate.userId, candidate.name]),
        )}
        reorderSafe={reorderSafe}
        creating={createDocument.isPending}
        onSearchChange={setSearch}
        onTabChange={setListTab}
        onCreate={(parentId) => void create(parentId, listTab === 'private')}
        onUpload={(file) => void upload(file)}
        onRetry={() => void visibleDocumentsQuery.refetch()}
      />
    );
  }

  return (
    <DocumentView
      key={documentId}
      projectKey={projectKey}
      documentId={documentId}
      onBack={() => router.push(documentsPath(projectKey))}
      onCreated={() => setSearch('')}
      onDeleted={() => router.push(documentsPath(projectKey))}
    />
  );
}