Skip to content

Papermark is the open-source DocSend alternative and secure data rooms with built-in analytics and custom domains.

48.0 KB
Raw Blame
import { NextRequest, NextResponse } from "next/server";

import { reportDeniedAccessAttempt } from "@/ee/features/access-notifications";
import { ItemType, LinkAudienceType, LinkType } from "@prisma/client";
import { ipAddress, waitUntil } from "@vercel/functions";
import { getServerSession } from "next-auth";

import { hashToken } from "@/lib/api/auth/token";
import { authOptions } from "@/lib/auth/auth-options";
import {
  DataroomSession,
  collectFingerprintHeaders,
  createDataroomSession,
  generateSessionFingerprint,
} from "@/lib/auth/dataroom-auth";
import { verifyDataroomSession } from "@/lib/auth/dataroom-auth";
import { PreviewSession, verifyPreviewSession } from "@/lib/auth/preview-auth";
import { isEmbeddableUrl } from "@/lib/edge-config/embeddable-domains";
import { sendOtpVerificationEmail } from "@/lib/emails/send-email-otp-verification";
import { getFeatureFlags } from "@/lib/featureFlags";
import { getAdvancedExcelFileUrl } from "@/lib/files/advanced-excel-url";
import { getFile } from "@/lib/files/get-file";
import { signPageLinks } from "@/lib/files/sign-page-links";
import { newId } from "@/lib/id-helper";
import {
  notifyDataroomAccess,
  notifyDocumentView,
} from "@/lib/integrations/slack/events";
import prisma from "@/lib/prisma";
import { ratelimit } from "@/lib/redis";
import { parseSheet } from "@/lib/sheet";
import {
  getSignedAgreementAccessCookieName,
  parseSignedAgreementAccessToken,
} from "@/lib/signing/access-token";
import {
  ensureAgreementResponseForAccess,
  normalizeSignerEmail,
  normalizeSignerName,
} from "@/lib/signing/agreements";
import { recordLinkView } from "@/lib/tracking/record-link-view";
import { CustomUser, WatermarkConfigSchema } from "@/lib/types";
import {
  checkPassword,
  decryptEncrpytedPassword,
  log,
  stripTrailingPasswordWhitespace,
} from "@/lib/utils";
import {
  extractEmailDomain,
  normalizeGroupDomain,
} from "@/lib/utils/email-domain";
import { generateOTP } from "@/lib/utils/generate-otp";
import { LOCALHOST_IP } from "@/lib/utils/geo";
import { checkViewerEmailAccess } from "@/lib/utils/global-block-list";
import { resolveHtmlContentForRender } from "@/lib/utils/html-document";
import { validateEmail } from "@/lib/utils/validate-email";

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();

    const {
      linkId,
      documentId,
      dataroomId,
      userId,
      documentVersionId,
      documentName,
      hasPages,
      ownerId,
      linkType,
      dataroomViewId,
      viewType,
      groupId,
      startPage,
      ...data
    } = body as {
      linkId: string;
      documentId: string | undefined;
      dataroomId: string;
      userId: string | null;
      documentVersionId: string | undefined;
      documentName: string | undefined;
      hasPages: boolean | undefined;
      ownerId: string | null;
      linkType: string;
      dataroomViewId?: string;
      viewType: "DATAROOM_VIEW" | "DOCUMENT_VIEW";
      groupId?: string;
      startPage?: number;
    };

    const {
      email,
      password,
      name,
      agreementResponseId,
      hasConfirmedAgreement,
    } = data as {
      email: string;
      password: string;
      name?: string;
      agreementResponseId?: string;
      hasConfirmedAgreement?: boolean;
    };

    // Add customFields to the data extraction
    const { customFields } = data as {
      customFields?: { [key: string]: string };
    };

    // INFO: for using the advanced excel viewer
    let { useAdvancedExcelViewer } = data as {
      useAdvancedExcelViewer: boolean;
    };

    // previewToken is used to determine if the view is a preview and therefore should not be recorded
    const { previewToken } = data as {
      previewToken?: string;
    };

    // Email Verification Data
    const { code, token, verifiedEmail } = data as {
      code?: string;
      token?: string;
      verifiedEmail?: string;
    };

    // Fetch the link to verify the settings
    const link = await prisma.link.findUnique({
      where: {
        id: linkId,
      },
      select: {
        id: true,
        name: true,
        documentId: true,
        dataroomId: true,
        emailProtected: true,
        enableNotification: true,
        emailAuthenticated: true,
        password: true,
        domainSlug: true,
        isArchived: true,
        deletedAt: true,
        expiresAt: true,
        slug: true,
        domainId: true,
        linkType: true,
        allowList: true,
        denyList: true,
        enableAgreement: true,
        agreementId: true,
        agreement: {
          select: {
            id: true,
            signingProvider: true,
            contentType: true,
            requireName: true,
          },
        },
        enableWatermark: true,
        watermarkConfig: true,
        groupId: true,
        group: {
          select: {
            members: { include: { viewer: { select: { email: true } } } },
            domains: true,
            allowAll: true,
          },
        },
        permissionGroupId: true,
        audienceType: true,
        allowDownload: true,
        enableConversation: true,
        teamId: true,
        brandId: true,
        team: {
          select: {
            plan: true,
            globalBlockList: true,
            agentsEnabled: true,
            pauseStartsAt: true,
          },
        },
        customFields: {
          select: {
            identifier: true,
            label: true,
          },
        },
        enableUpload: true,
        uploadFolderIds: true,
        dataroom: {
          select: {
            agentsEnabled: true,
            isFrozen: true,
            name: true,
            brandId: true,
          },
        },
        visitorGroups: {
          select: {
            visitorGroup: {
              select: {
                emails: true,
              },
            },
          },
        },
      },
    });

    if (!link) {
      return NextResponse.json({ message: "Link not found." }, { status: 404 });
    }

    if (link.isArchived) {
      return NextResponse.json(
        { message: "Link is no longer available." },
        { status: 404 },
      );
    }

    if (link.deletedAt) {
      return NextResponse.json(
        { message: "Link has been deleted." },
        { status: 404 },
      );
    }

    if (link.expiresAt && new Date(link.expiresAt) < new Date()) {
      return NextResponse.json(
        { message: "Link has expired." },
        { status: 404 },
      );
    }

    if (link.dataroom?.isFrozen) {
      return NextResponse.json(
        { message: "This data room has been closed." },
        { status: 403 },
      );
    }

    let isEmailVerified: boolean = false;
    let hashedVerificationToken: string | null = null;
    // Check if the user is part of the team and therefore skip verification steps
    let isTeamMember: boolean = false;
    let isPreview: boolean = false;
    if (userId && previewToken) {
      const session = await getServerSession(authOptions);
      if (!session) {
        return NextResponse.json(
          { message: "You need to be logged in to preview the link." },
          { status: 401 },
        );
      }

      const sessionUserId = (session.user as CustomUser).id;
      const teamMembership = await prisma.userTeam.findUnique({
        where: {
          userId_teamId: {
            userId: sessionUserId,
            teamId: link.teamId!,
          },
        },
      });
      if (teamMembership) {
        isTeamMember = true;
        isPreview = true;
        isEmailVerified = true;
      }
    }

    // Check if there's a valid preview session
    let previewSession: PreviewSession | null = null;
    if (!isPreview && previewToken) {
      const session = await getServerSession(authOptions);
      if (!session) {
        return NextResponse.json(
          { message: "You need to be logged in to preview the link." },
          { status: 401 },
        );
      }
      previewSession = await verifyPreviewSession(
        previewToken,
        (session.user as CustomUser).id,
        linkId,
      );

      if (!previewSession) {
        return NextResponse.json(
          {
            message: "Preview session expired or invalid. Request a new one.",
            resetPreview: true,
          },
          { status: 401 },
        );
      }
      isPreview = true;
    }

    let dataroomSession: DataroomSession | null = null;
    if (!isPreview) {
      dataroomSession = await verifyDataroomSession(
        request,
        linkId,
        link.dataroomId!,
      );

      // If we have a dataroom session, use its verified status
      if (dataroomSession) {
        isEmailVerified = dataroomSession.verified;
      }
    }

    let effectiveEmail = normalizeSignerEmail(email);
    let effectiveName = normalizeSignerName(name);

    const signedAccessCookieValue =
      link.enableAgreement && link.agreement
        ? request.cookies.get(getSignedAgreementAccessCookieName(linkId))?.value
        : undefined;
    const signedAccessPayload = parseSignedAgreementAccessToken(
      signedAccessCookieValue,
    );
    const cookieAgreementResponseId =
      link.enableAgreement &&
      link.agreement &&
      signedAccessPayload &&
      signedAccessPayload.linkId === linkId &&
      signedAccessPayload.agreementId === link.agreement.id
        ? signedAccessPayload.agreementResponseId
        : null;

    let verifiedAgreementResponse: Awaited<
      ReturnType<typeof ensureAgreementResponseForAccess>
    > | null = null;

    // If there is no session, then we need to check if the link is protected and enforce the checks
    if (!dataroomSession && !isPreview) {
      if (cookieAgreementResponseId && link.enableAgreement && link.agreement) {
        try {
          verifiedAgreementResponse = await ensureAgreementResponseForAccess({
            agreement: link.agreement,
            linkId,
            agreementResponseId: cookieAgreementResponseId,
            skipSignerIdentityCheck: true,
          });
          effectiveEmail =
            normalizeSignerEmail(verifiedAgreementResponse.signerEmail) ??
            effectiveEmail;
          effectiveName =
            normalizeSignerName(verifiedAgreementResponse.signerName) ??
            effectiveName;
        } catch {
          // Continue with the submitted identity; the agreement gate below will fail closed if needed.
        }
      }

      // Check if email is required for visiting the link
      if (link.emailProtected) {
        if (!effectiveEmail || effectiveEmail.trim() === "") {
          return NextResponse.json(
            { message: "Email is required." },
            { status: 400 },
          );
        }

        // validate email
        if (!validateEmail(effectiveEmail)) {
          return NextResponse.json(
            { message: "Invalid email address." },
            { status: 400 },
          );
        }
      }

      // Check if password is required for visiting the link
      if (link.password) {
        if (!password || password.trim() === "") {
          return NextResponse.json(
            { message: "Password is required." },
            { status: 400 },
          );
        }

        let isPasswordValid: boolean = false;
        const submittedPassword = stripTrailingPasswordWhitespace(password);
        const textParts: string[] = link.password.split(":");
        if (!textParts || textParts.length !== 2) {
          isPasswordValid = await checkPassword(
            submittedPassword,
            link.password,
          );
          // A legacy bcrypt hash may cover trailing spaces, so the raw input
          // still has to match or those links lock their owners out.
          if (!isPasswordValid && password !== submittedPassword) {
            isPasswordValid = await checkPassword(password, link.password);
          }
        } else {
          const decryptedPassword = decryptEncrpytedPassword(link.password);
          isPasswordValid = decryptedPassword === submittedPassword;
        }

        if (!isPasswordValid) {
          return NextResponse.json(
            { message: "Invalid password." },
            { status: 403 },
          );
        }
      }

      // Fail closed when an agreement is required but not configured, to avoid silently granting access.
      if (link.enableAgreement && !link.agreement) {
        return NextResponse.json(
          { message: "Agreement is required but not configured." },
          { status: 500 },
        );
      }

      if (
        link.enableAgreement &&
        link.agreement &&
        !verifiedAgreementResponse
      ) {
        const resolvedAgreementResponseId =
          agreementResponseId ?? cookieAgreementResponseId ?? undefined;

        const hasCookieIdentityProof =
          !!cookieAgreementResponseId &&
          (!agreementResponseId ||
            agreementResponseId === cookieAgreementResponseId);

        try {
          verifiedAgreementResponse = await ensureAgreementResponseForAccess({
            agreement: link.agreement,
            linkId,
            agreementResponseId: resolvedAgreementResponseId,
            hasConfirmedAgreement,
            signerEmail: effectiveEmail,
            signerName: effectiveName,
            requireSignerEmail: link.emailProtected,
            skipSignerIdentityCheck: hasCookieIdentityProof,
          });
          effectiveEmail =
            normalizeSignerEmail(verifiedAgreementResponse.signerEmail) ??
            effectiveEmail;
          effectiveName =
            normalizeSignerName(verifiedAgreementResponse.signerName) ??
            effectiveName;
        } catch (error) {
          return NextResponse.json(
            {
              message:
                error instanceof Error
                  ? error.message
                  : "Agreement signing is required.",
            },
            { status: 400 },
          );
        }
      }

      // Allow list and viewer-group audience override the team-wide global
      // block list. Per-link deny list still applies after.
      const isGroupAudience =
        link.audienceType === LinkAudienceType.GROUP && !!link.groupId;
      if (isGroupAudience && !link.group) {
        return NextResponse.json(
          { message: "Group not found." },
          { status: 404 },
        );
      }

      const viewerGroup = isGroupAudience ? link.group : null;
      const visitorGroupEmails =
        link.visitorGroups?.flatMap((vg) => vg.visitorGroup.emails) || [];
      const viewerGroupAllowEntries =
        viewerGroup && !viewerGroup.allowAll
          ? [
              ...viewerGroup.members.map((member) => member.viewer.email),
              ...viewerGroup.domains,
            ]
          : [];
      const emailAccess = checkViewerEmailAccess({
        email: effectiveEmail ?? undefined,
        allowList: [
          ...(link.allowList || []),
          ...visitorGroupEmails,
          ...viewerGroupAllowEntries,
        ],
        denyList: link.denyList,
        globalBlockList: link.team?.globalBlockList,
      });
      if (emailAccess.denied) {
        if (emailAccess.error) {
          return NextResponse.json(
            { message: emailAccess.error },
            { status: 400 },
          );
        }

        waitUntil(
          reportDeniedAccessAttempt(
            link,
            effectiveEmail ?? "",
            emailAccess.reason,
          ),
        );

        return NextResponse.json(
          {
            message:
              emailAccess.reason === "global"
                ? "Access denied"
                : "Unauthorized access",
          },
          { status: 403 },
        );
      }

      if (viewerGroup && !viewerGroup.allowAll) {
        const isMember = viewerGroup.members.some(
          (member) => member.viewer.email === effectiveEmail,
        );

        const emailDomain = extractEmailDomain(effectiveEmail ?? "");
        const hasDomainAccess = emailDomain
          ? viewerGroup.domains.some(
              (domain) => normalizeGroupDomain(domain) === emailDomain,
            )
          : false;

        if (!isMember && !hasDomainAccess) {
          waitUntil(
            reportDeniedAccessAttempt(link, effectiveEmail ?? "", "allow"),
          );
          return NextResponse.json(
            { message: "Unauthorized access" },
            { status: 403 },
          );
        }
      }

      // Request OTP Code for email verification if
      // 1) email verification is required and
      // 2) code is not provided or token not provided
      if (link.emailAuthenticated && !code && !token) {
        const ipAddressValue = ipAddress(request);

        // Rate limit per email/link combination (1 per 30 seconds) to prevent OTP flooding
        const { success: emailLimitSuccess } = await ratelimit(1, "30 s").limit(
          `send-otp:${linkId}:${effectiveEmail}`,
        );
        if (!emailLimitSuccess) {
          return NextResponse.json(
            {
              message:
                "Please wait before requesting another code. Try again in 30 seconds.",
            },
            { status: 429 },
          );
        }

        // Additional IP-based rate limit (10 per minute) to prevent abuse across different emails
        const { success } = await ratelimit(10, "1 m").limit(
          `send-otp:${ipAddressValue}`,
        );
        if (!success) {
          return NextResponse.json(
            { message: "Too many requests. Please try again later." },
            { status: 429 },
          );
        }

        await prisma.verificationToken.deleteMany({
          where: {
            identifier: `otp:${linkId}:${effectiveEmail}`,
          },
        });

        const otpCode = generateOTP();
        const expiresAt = new Date();
        expiresAt.setMinutes(expiresAt.getMinutes() + 10); // token expires at 10 minutes

        await prisma.verificationToken.create({
          data: {
            token: otpCode,
            identifier: `otp:${linkId}:${effectiveEmail}`,
            expires: expiresAt,
          },
        });

        waitUntil(
          sendOtpVerificationEmail(
            effectiveEmail ?? "",
            otpCode,
            true,
            link.teamId!,
            {
              linkBrandId: link.brandId,
              dataroomBrandId: link.dataroom?.brandId,
            },
          ),
        );
        return NextResponse.json(
          {
            type: "email-verification",
            message: "Verification email sent.",
          },
          { status: 200 },
        );
      }

      if (link.emailAuthenticated && code) {
        const ipAddressValue = ipAddress(request);
        const { success } = await ratelimit(10, "1 m").limit(
          `verify-otp:${ipAddressValue}`,
        );
        if (!success) {
          return NextResponse.json(
            { message: "Too many requests. Please try again later." },
            { status: 429 },
          );
        }

        // Check if the OTP code is valid
        const verification = await prisma.verificationToken.findUnique({
          where: {
            token: code,
            identifier: `otp:${linkId}:${effectiveEmail}`,
          },
        });

        if (!verification) {
          return NextResponse.json(
            {
              message: "Unauthorized access. Request new access.",
              resetVerification: true,
            },
            { status: 401 },
          );
        }

        // Check the OTP code's expiration date
        if (Date.now() > verification.expires.getTime()) {
          await prisma.verificationToken.delete({
            where: {
              token: code,
            },
          });
          return NextResponse.json(
            {
              message: "Access expired. Request new access.",
              resetVerification: true,
            },
            { status: 401 },
          );
        }

        // delete the OTP code after verification
        await prisma.verificationToken.delete({
          where: {
            token: code,
          },
        });

        // Create a email verification token for repeat access
        const token = newId("email");
        hashedVerificationToken = hashToken(token);
        const tokenExpiresAt = new Date();
        tokenExpiresAt.setHours(tokenExpiresAt.getHours() + 23); // token expires at 23 hours
        await prisma.verificationToken.create({
          data: {
            token: hashedVerificationToken,
            identifier: `link-verification:${linkId}:${link.teamId}:${effectiveEmail}`,
            expires: tokenExpiresAt,
          },
        });

        isEmailVerified = true;
      }

      if (link.emailAuthenticated && token) {
        const ipAddressValue = ipAddress(request);
        const { success } = await ratelimit(10, "1 m").limit(
          `verify-email:${ipAddressValue}`,
        );
        if (!success) {
          return NextResponse.json(
            { message: "Too many requests. Please try again later." },
            { status: 429 },
          );
        }

        // Check if the long-term verification token is valid
        const verification = await prisma.verificationToken.findUnique({
          where: {
            token: token,
            identifier: `link-verification:${linkId}:${link.teamId}:${effectiveEmail}`,
          },
        });

        if (!verification) {
          return NextResponse.json(
            {
              message: "Unauthorized access. Request new access.",
              resetVerification: true,
            },
            { status: 401 },
          );
        }

        // Check the long-term verification token's expiration date
        if (Date.now() > verification.expires.getTime()) {
          // delete the long-term verification token after verification
          await prisma.verificationToken.delete({
            where: {
              token: token,
            },
          });
          return NextResponse.json(
            {
              message: "Access expired. Request new access.",
              resetVerification: true,
            },
            { status: 401 },
          );
        }

        isEmailVerified = true;
      }
    }

    if (
      !verifiedAgreementResponse &&
      cookieAgreementResponseId &&
      link.enableAgreement &&
      link.agreement
    ) {
      try {
        verifiedAgreementResponse = await ensureAgreementResponseForAccess({
          agreement: link.agreement,
          linkId,
          agreementResponseId: cookieAgreementResponseId,
          skipSignerIdentityCheck: true,
        });
        effectiveEmail =
          normalizeSignerEmail(verifiedAgreementResponse.signerEmail) ??
          effectiveEmail;
        effectiveName =
          normalizeSignerName(verifiedAgreementResponse.signerName) ??
          effectiveName;
      } catch {
        // Existing dataroom sessions still grant access; ignore stale signed identity cookies.
      }
    }

    const hasSignedAgreementIdentity = !!normalizeSignerEmail(
      verifiedAgreementResponse?.signerEmail,
    );

    let viewer: { id: string; email: string; verified: boolean } | null = null;
    if (!isPreview) {
      if (!dataroomSession) {
        if (effectiveEmail) {
          // find or create a viewer
          console.time("find-viewer");
          viewer = await prisma.viewer.findUnique({
            where: {
              teamId_email: {
                teamId: link.teamId!,
                email: effectiveEmail,
              },
            },
            select: { id: true, email: true, verified: true },
          });
          console.timeEnd("find-viewer");

          if (!viewer) {
            console.time("create-viewer");
            viewer = await prisma.viewer.create({
              data: {
                email: effectiveEmail,
                verified: isEmailVerified,
                teamId: link.teamId!,
              },
              select: { id: true, email: true, verified: true },
            });
            console.timeEnd("create-viewer");
          }
        }
      } else {
        if (dataroomSession.viewerId) {
          viewer = await prisma.viewer.findUnique({
            where: { id: dataroomSession.viewerId, teamId: link.teamId! },
            select: { id: true, email: true, verified: true },
          });
        }

        if (
          hasSignedAgreementIdentity &&
          effectiveEmail &&
          (!viewer || viewer.email.toLowerCase() !== effectiveEmail)
        ) {
          viewer = await prisma.viewer.findUnique({
            where: {
              teamId_email: {
                teamId: link.teamId!,
                email: effectiveEmail,
              },
            },
            select: { id: true, email: true, verified: true },
          });

          if (!viewer) {
            viewer = await prisma.viewer.create({
              data: {
                email: effectiveEmail,
                verified: isEmailVerified,
                teamId: link.teamId!,
              },
              select: { id: true, email: true, verified: true },
            });
          }
        }
      }

      if (viewer && !viewer.verified && isEmailVerified) {
        await prisma.viewer.update({
          where: { id: viewer.id },
          data: { verified: isEmailVerified },
        });
        // Update the viewer object to reflect the new verified status
        viewer.verified = isEmailVerified;
      }

      if (dataroomSession?.viewId && hasSignedAgreementIdentity && viewer) {
        await prisma.view.updateMany({
          where: {
            id: dataroomSession.viewId,
            linkId,
            dataroomId: link.dataroomId,
            viewType: "DATAROOM_VIEW",
          },
          data: {
            viewerEmail: viewer.email,
            viewerName: effectiveName ?? undefined,
            viewerId: viewer.id,
            verified: viewer.verified || isEmailVerified,
          },
        });
      }
    }

    const shouldRefreshDataroomSession = Boolean(
      dataroomSession &&
      hasSignedAgreementIdentity &&
      viewer &&
      dataroomSession.viewerId !== viewer.id,
    );

    // Common fields for the view object shared between DATAROOM_VIEW and DOCUMENT_VIEW
    const viewFields = {
      linkId: linkId,
      viewerEmail: viewer?.email ?? effectiveEmail,
      viewerName: effectiveName,
      verified: isEmailVerified,
      dataroomId: link.dataroomId,
      viewerId: viewer?.id ?? undefined,
      teamId: link.teamId,
      ...(link.audienceType === LinkAudienceType.GROUP &&
        link.groupId && {
          groupId: link.groupId,
        }),
      ...(customFields &&
        link.customFields.length > 0 && {
          customFieldResponse: {
            create: {
              data: link.customFields.map((field) => ({
                identifier: field.identifier,
                label: field.label,
                response: customFields[field.identifier] || "",
              })),
            },
          },
        }),
    };

    const isPaused =
      link.team?.pauseStartsAt && link.team?.pauseStartsAt <= new Date()
        ? true
        : false;

    // ** DATAROOM_VIEW **
    if (viewType === "DATAROOM_VIEW") {
      try {
        let newDataroomView: { id: string } | null = null;
        if (!isPreview) {
          if (!dataroomSession) {
            console.time("create-view");
            newDataroomView = await prisma.view.create({
              data: { ...viewFields, viewType: "DATAROOM_VIEW" },
              select: { id: true },
            });

            if (verifiedAgreementResponse) {
              await prisma.agreementResponse.update({
                where: {
                  id: verifiedAgreementResponse.id,
                },
                data: {
                  viewId: newDataroomView.id,
                },
              });
            }
            console.timeEnd("create-view");
          }
        }

        // Send events in the background to avoid blocking the response
        if (newDataroomView) {
          waitUntil(
            // Record link view in Tinybird
            recordLinkView({
              req: request,
              clickId: newId("linkView"),
              viewId: newDataroomView.id,
              linkId,
              dataroomId: link.dataroomId!,
              teamId: link.teamId!,
              enableNotification: link.enableNotification,
              isPaused,
            }),
          );

          if (link.teamId && !isPreview) {
            waitUntil(
              (async () => {
                try {
                  await notifyDataroomAccess({
                    teamId: link.teamId!,
                    dataroomId: link.dataroomId!,
                    linkId,
                    viewerEmail: effectiveEmail ?? verifiedEmail ?? undefined,
                    viewerId: viewer?.id,
                    teamIsPaused: isPaused,
                  });
                } catch (error) {
                  console.error("Error sending Slack notification:", error);
                }
              })(),
            );
          }
        }

        const dataroomViewId =
          newDataroomView?.id ?? dataroomSession?.viewId ?? undefined;

        // Resolve the upload-destination allow-list so the visitor UI can
        // surface exactly which folders they may target. Null/empty = no
        // restriction (visitor may upload into any folder they're in).
        let uploadFolderAllowList:
          | { id: string; name: string; path: string }[]
          | null = null;
        if (link.enableUpload) {
          const allowedIds = Array.isArray(link.uploadFolderIds)
            ? link.uploadFolderIds.filter(
                (id): id is string => typeof id === "string" && !!id,
              )
            : [];
          if (allowedIds.length > 0) {
            const folders = await prisma.dataroomFolder.findMany({
              where: {
                id: { in: allowedIds },
                dataroomId: link.dataroomId!,
              },
              select: { id: true, name: true, path: true },
            });
            const byId = new Map(folders.map((f) => [f.id, f]));
            uploadFolderAllowList = allowedIds
              .map((id) => byId.get(id))
              .filter(
                (f): f is { id: string; name: string; path: string } => !!f,
              );
          }
        }

        const returnObject = {
          message: "Dataroom View recorded",
          viewId: dataroomViewId,
          isPreview: isPreview ? true : undefined,
          file: undefined,
          pages: undefined,
          notionData: undefined,
          verificationToken: hashedVerificationToken,
          viewerId: viewer?.id,
          conversationsEnabled: link.enableConversation,
          enableVisitorUpload: link.enableUpload,
          uploadFolderAllowList,
          agentsEnabled: link.dataroom?.agentsEnabled ?? false,
          dataroomName: link.dataroom?.name,
          ...(isTeamMember && { isTeamMember: true }),
        };

        const response = NextResponse.json(returnObject, { status: 200 });

        // Create or refresh the dataroom session token when the signed identity is canonical.
        if ((!dataroomSession || shouldRefreshDataroomSession) && !isPreview) {
          const sessionViewId = newDataroomView?.id ?? dataroomSession?.viewId;

          if (!sessionViewId) {
            return response;
          }

          const fingerprint = generateSessionFingerprint(
            collectFingerprintHeaders(request.headers),
          );
          const newDataroomSession = await createDataroomSession(
            link.dataroomId!,
            linkId,
            sessionViewId,
            ipAddress(request) ?? LOCALHOST_IP,
            isEmailVerified,
            viewer?.id,
            fingerprint,
          );

          let basePath = `/view/${linkId}`;
          const cookieId = `pm_drs_${linkId}`;
          let flagCookieId = `pm_drs_flag_${linkId}`;

          if (link.domainId) {
            basePath = `/${link.slug}`;
            flagCookieId = `pm_drs_flag_${link.slug}`;
          }

          response.cookies.set(cookieId, newDataroomSession?.token, {
            path: "/",
            expires: new Date(newDataroomSession?.expiresAt),
            httpOnly: true,
            sameSite: "strict",
          });
          response.cookies.set(flagCookieId, "true", {
            path: basePath,
            expires: new Date(newDataroomSession?.expiresAt),
            sameSite: "strict",
          });
        }

        return response;
      } catch (error) {
        log({
          message: `Failed to record view for dataroom link: ${linkId}. \n\n ${error}`,
          type: "error",
          mention: true,
        });
        return NextResponse.json(
          { message: (error as Error).message },
          { status: 500 },
        );
      }
    }

    // ** DOCUMENT_VIEW **
    try {
      if (!documentVersionId) {
        return NextResponse.json(
          { message: "Document version ID is required." },
          { status: 400 },
        );
      }

      const documentVersionAccess = await prisma.documentVersion.findUnique({
        where: { id: documentVersionId },
        select: { documentId: true },
      });

      if (!documentVersionAccess) {
        return NextResponse.json(
          { message: "Document version not found." },
          { status: 404 },
        );
      }

      const effectiveGroupId = link.groupId || link.permissionGroupId;
      let dataroomDocument: { id: string } | null = null;
      let dataroomDocumentPermission: {
        canView: boolean;
        canDownload: boolean;
      } | null = null;

      if (link.linkType !== LinkType.DATAROOM_LINK || !link.dataroomId) {
        return NextResponse.json(
          { message: "Unauthorized access." },
          { status: 403 },
        );
      }

      dataroomDocument = await prisma.dataroomDocument.findUnique({
        where: {
          dataroomId_documentId: {
            dataroomId: link.dataroomId,
            documentId: documentVersionAccess.documentId,
          },
        },
        select: { id: true },
      });

      if (!dataroomDocument) {
        return NextResponse.json(
          { message: "Unauthorized access." },
          { status: 403 },
        );
      }

      if (effectiveGroupId) {
        if (link.groupId) {
          dataroomDocumentPermission =
            await prisma.viewerGroupAccessControls.findUnique({
              where: {
                groupId_itemId: {
                  groupId: link.groupId,
                  itemId: dataroomDocument.id,
                },
                itemType: ItemType.DATAROOM_DOCUMENT,
              },
              select: { canView: true, canDownload: true },
            });
        } else if (link.permissionGroupId) {
          dataroomDocumentPermission =
            await prisma.permissionGroupAccessControls.findUnique({
              where: {
                groupId_itemId: {
                  groupId: link.permissionGroupId,
                  itemId: dataroomDocument.id,
                },
                itemType: ItemType.DATAROOM_DOCUMENT,
              },
              select: { canView: true, canDownload: true },
            });
        }

        if (
          !dataroomDocumentPermission?.canView &&
          !dataroomDocumentPermission?.canDownload
        ) {
          // Fallback: viewer-uploaded docs aren't tied to the link's
          // permission group, so allow the original uploader through. Gated
          // on a verified session (or NextAuth team-member preview) to
          // prevent unverified callers from claiming an upload's viewerId.
          const allowUploadFallback = isEmailVerified || isTeamMember;
          const ownerViewerId = viewer?.id ?? dataroomSession?.viewerId;
          const viewerUpload =
            ownerViewerId || isTeamMember
              ? await prisma.documentUpload.findFirst({
                  where: {
                    linkId,
                    dataroomDocumentId: dataroomDocument.id,
                    ...(ownerViewerId && !isTeamMember
                      ? { viewerId: ownerViewerId }
                      : {}),
                  },
                  select: { id: true },
                })
              : null;

          if (!viewerUpload) {
            return NextResponse.json(
              { message: "Unauthorized access." },
              { status: 403 },
            );
          }

          if (!allowUploadFallback) {
            // Trigger inline OTP re-auth. Echoing the email back is safe
            // here — the caller supplied it on the access form.
            return NextResponse.json(
              {
                message: "Email verification required to access your upload.",
                requiresVerification: "viewer-upload",
                email: viewer?.email ?? null,
              },
              { status: 401 },
            );
          }

          // Per-link `allowDownload` still gates the download UI downstream.
          dataroomDocumentPermission = { canView: true, canDownload: true };
        }
      }

      const resolvedDocumentId = documentVersionAccess.documentId;
      let newView: { id: string } | null = null;
      let dataroomView: { id: string } | null = null;
      if (!isPreview) {
        console.time("create-view");

        // if dataroomSession is not present, create a dataroom view first
        if (!dataroomSession) {
          dataroomView = await prisma.view.create({
            data: { ...viewFields, viewType: "DATAROOM_VIEW" },
            select: { id: true },
          });

          if (verifiedAgreementResponse) {
            await prisma.agreementResponse.update({
              where: {
                id: verifiedAgreementResponse.id,
              },
              data: {
                viewId: dataroomView.id,
              },
            });
          }

          waitUntil(
            // Record link view in Tinybird
            recordLinkView({
              req: request,
              clickId: newId("linkView"),
              viewId: dataroomView.id,
              linkId,
              dataroomId: link.dataroomId!,
              teamId: link.teamId!,
              enableNotification: link.enableNotification,
              isPaused,
            }),
          );
        }

        // create the document view
        newView = await prisma.view.create({
          data: {
            ...viewFields,
            documentId: resolvedDocumentId,
            dataroomViewId:
              dataroomSession?.viewId ?? dataroomView?.id ?? dataroomViewId,
            viewType: "DOCUMENT_VIEW",
          },
          select: { id: true },
        });
        console.timeEnd("create-view");
        // Only send Slack notifications for non-preview views
        if (link.teamId && !isPreview) {
          waitUntil(
            (async () => {
              try {
                await notifyDocumentView({
                  teamId: link.teamId!,
                  documentId: resolvedDocumentId,
                  dataroomId: link.dataroomId!,
                  linkId,
                  viewerEmail: effectiveEmail ?? verifiedEmail ?? undefined,
                  viewerId: viewer?.id,
                  teamIsPaused: isPaused,
                });
              } catch (error) {
                console.error("Error sending Slack notification:", error);
              }
            })(),
          );
        }
      }

      // if document version has pages, then return pages
      // otherwise, return file from document version
      let documentPages, documentVersion;
      let sheetData;
      let htmlContent: string | undefined;
      const INITIAL_PAGES_TO_LOAD = 10;

      if (hasPages) {
        // get pages from document version
        console.time("get-pages");
        documentPages = await prisma.documentPage.findMany({
          where: { versionId: documentVersionId },
          orderBy: { pageNumber: "asc" },
          select: {
            file: true,
            storageType: true,
            pageNumber: true,
            embeddedLinks: !link.team?.plan.includes("free"),
            pageLinks: !link.team?.plan.includes("free"),
            metadata: true,
          },
        });

        // Sign URLs for pages around the requested start page (or page 1 by default).
        // Remaining page URLs are fetched on-demand by the client via /api/views/pages.
        const centerIndex = Math.min(
          Math.max(0, (startPage ?? 1) - 1),
          Math.max(0, documentPages.length - 1),
        );
        const halfWindow = Math.floor(INITIAL_PAGES_TO_LOAD / 2);
        const signStart = Math.max(0, centerIndex - halfWindow);
        const signEnd = Math.min(
          documentPages.length,
          signStart + INITIAL_PAGES_TO_LOAD,
        );

        documentPages = await Promise.all(
          documentPages.map(async (page, index) => {
            const { storageType, ...otherPage } = page;
            const inWindow = index >= signStart && index < signEnd;
            return {
              ...otherPage,
              file: inWindow
                ? await getFile({ data: page.file, type: storageType })
                : null,
              pageLinks: inWindow
                ? ((await signPageLinks(otherPage.pageLinks)) ??
                  otherPage.pageLinks)
                : otherPage.pageLinks,
            };
          }),
        );

        console.timeEnd("get-pages");
      } else {
        // get file from document version
        console.time("get-file");
        documentVersion = await prisma.documentVersion.findUnique({
          where: { id: documentVersionId },
          select: {
            file: true,
            storageType: true,
            type: true,
          },
        });

        if (!documentVersion) {
          return NextResponse.json(
            { message: "Document version not found." },
            { status: 404 },
          );
        }

        if (
          documentVersion.type === "pdf" ||
          documentVersion.type === "image" ||
          documentVersion.type === "video"
        ) {
          documentVersion.file = await getFile({
            data: documentVersion.file,
            type: documentVersion.storageType,
          });
        }
        // For link documents, the file is already a URL, no processing needed
        if (documentVersion.type === "sheet") {
          const document = await prisma.document.findUnique({
            where: { id: resolvedDocumentId },
            select: { advancedExcelEnabled: true },
          });
          useAdvancedExcelViewer = document?.advancedExcelEnabled ?? false;

          if (useAdvancedExcelViewer) {
            documentVersion.file = await getAdvancedExcelFileUrl({
              file: documentVersion.file,
              storageType: documentVersion.storageType,
            });
          } else {
            const fileUrl = await getFile({
              data: documentVersion.file,
              type: documentVersion.storageType,
            });

            const data = await parseSheet({ fileUrl });
            sheetData = data;
          }
        }

        if (documentVersion.type === "html") {
          const featureFlags = await getFeatureFlags({ teamId: link.teamId! });
          if (!featureFlags.htmlDocuments) {
            return NextResponse.json(
              { message: "This document is not available for viewing." },
              { status: 400 },
            );
          }

          try {
            const fileUrl = await getFile({
              data: documentVersion.file,
              type: documentVersion.storageType,
            });
            htmlContent = await resolveHtmlContentForRender({
              documentId: resolvedDocumentId,
              url: fileUrl,
            });
          } catch (error) {
            console.error("Failed to load HTML document for rendering:", error);
            return NextResponse.json(
              { message: "This document could not be loaded." },
              { status: 400 },
            );
          }
        }
        console.timeEnd("get-file");
      }

      // check if viewer can download the document based on group permissions
      let canDownload: boolean = link.allowDownload ?? false;

      if (
        link.allowDownload &&
        (link.audienceType === LinkAudienceType.GROUP ||
          link.permissionGroupId) &&
        effectiveGroupId &&
        dataroomDocument
      ) {
        canDownload = dataroomDocumentPermission?.canDownload ?? false;
      }

      const isLinkType = documentVersion?.type === "link";
      const isEmbeddable = isLinkType
        ? await isEmbeddableUrl(documentVersion?.file)
        : false;

      const returnObject = {
        message: "View recorded",
        viewId: !isPreview && newView ? newView.id : undefined,
        isPreview: isPreview ? true : undefined,
        file:
          (documentVersion &&
            (documentVersion.type === "pdf" ||
              documentVersion.type === "image" ||
              documentVersion.type === "zip" ||
              documentVersion.type === "video" ||
              documentVersion.type === "link")) ||
          (documentVersion && useAdvancedExcelViewer)
            ? documentVersion.file
            : undefined,
        pages: documentPages ? documentPages : undefined,
        notionData: undefined,
        sheetData:
          documentVersion &&
          documentVersion.type === "sheet" &&
          !useAdvancedExcelViewer
            ? sheetData
            : undefined,
        htmlContent:
          documentVersion && documentVersion.type === "html"
            ? htmlContent
            : undefined,
        fileType: documentVersion
          ? documentVersion.type
          : documentPages
            ? "pdf"
            : undefined,
        watermarkConfig: link.enableWatermark
          ? link.watermarkConfig
          : undefined,
        viewerEmail: viewer?.email ?? effectiveEmail ?? verifiedEmail ?? null,
        ipAddress:
          link.enableWatermark &&
          link.watermarkConfig &&
          WatermarkConfigSchema.parse(link.watermarkConfig).text.includes(
            "{{ipAddress}}",
          )
            ? (ipAddress(request) ?? LOCALHOST_IP)
            : undefined,
        useAdvancedExcelViewer:
          documentVersion &&
          documentVersion.type === "sheet" &&
          useAdvancedExcelViewer
            ? useAdvancedExcelViewer
            : undefined,
        canDownload: canDownload,
        viewerId: viewer?.id,
        conversationsEnabled: link.enableConversation,
        agentsEnabled: link.dataroom?.agentsEnabled ?? false,
        dataroomName: link.dataroom?.name,
        ...(isTeamMember && { isTeamMember: true }),
        ...(isEmbeddable && { isEmbeddable: true }),
      };

      const response = NextResponse.json(returnObject, { status: 200 });

      // Create or refresh the dataroom session token when the signed identity is canonical.
      if ((!dataroomSession || shouldRefreshDataroomSession) && !isPreview) {
        const sessionViewId = dataroomView?.id ?? dataroomSession?.viewId;

        if (!sessionViewId) {
          return response;
        }

        const fingerprint = generateSessionFingerprint(
          collectFingerprintHeaders(request.headers),
        );
        const newDataroomSession = await createDataroomSession(
          link.dataroomId!,
          linkId,
          sessionViewId,
          ipAddress(request) ?? LOCALHOST_IP,
          isEmailVerified,
          viewer?.id,
          fingerprint,
        );

        let basePath = `/view/${linkId}`;
        const cookieId = `pm_drs_${linkId}`;
        let flagCookieId = `pm_drs_flag_${linkId}`;
        if (link.domainId) {
          basePath = `/${link.slug}`;
          flagCookieId = `pm_drs_flag_${link.slug}`;
        }

        response.cookies.set(cookieId, newDataroomSession?.token, {
          path: "/",
          expires: new Date(newDataroomSession?.expiresAt),
          httpOnly: true,
          sameSite: "strict",
        });
        response.cookies.set(flagCookieId, "true", {
          path: basePath,
          expires: new Date(newDataroomSession?.expiresAt),
          sameSite: "strict",
        });
      }

      return response;
    } catch (error) {
      log({
        message: `Failed to record view for dataroom document ${linkId}. \n\n ${error}`,
        type: "error",
        mention: true,
      });
      return NextResponse.json(
        { message: (error as Error).message },
        { status: 500 },
      );
    }
  } catch (error) {
    console.error(error);
    return NextResponse.json(
      { error: "Internal Server Error" },
      { status: 500 },
    );
  }
}