Skip to content

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

9.9 KB
Raw Blame
import { NextApiRequest, NextApiResponse } from "next";

import { parse as parseCookieHeader } from "cookie";
import { z } from "zod";

import { TeamError, errorhandler } from "@/lib/errorHandler";
import prisma from "@/lib/prisma";
import { ratelimit } from "@/lib/redis";
import {
  buildSignedAgreementAccessCookie,
  getSignedAgreementAccessCookieName,
  mintSignedAgreementAccessToken,
  parseSignedAgreementAccessToken,
  verifySignedAgreementAccessToken,
} from "@/lib/signing/access-token";
import {
  buildAgreementResponseSigningExternalId,
  getAgreementResponseSignedState,
  getAgreementSigningToken,
  getSigningEmbedConfig,
  isSigningAgreement,
} from "@/lib/signing/agreements";
import {
  SIGNED_DOWNLOAD_COOKIE_NAME,
  buildSignedAgreementDownloadCookie,
  mintSignedAgreementDownloadToken,
  verifySignedAgreementDownloadToken,
} from "@/lib/signing/download-token";
import { getIpAddress } from "@/lib/utils/ip";

const optionalEmailSchema = z.preprocess((value) => {
  if (typeof value !== "string") {
    return value;
  }

  const trimmedValue = value.trim().toLowerCase();

  return trimmedValue.length > 0 ? trimmedValue : null;
}, z.string().email().nullable().optional());

const optionalNameSchema = z.preprocess((value) => {
  if (typeof value !== "string") {
    return value;
  }

  const trimmedValue = value.trim();

  return trimmedValue.length > 0 ? trimmedValue : null;
}, z.string().max(255).nullable().optional());

const createSigningSessionSchema = z.object({
  agreementId: z.string().min(1, "Agreement ID is required."),
  linkId: z.string().min(1, "Link ID is required."),
  email: optionalEmailSchema,
  name: optionalNameSchema,
  agreementResponseId: z
    .string()
    .min(1)
    .nullable()
    .optional()
    .transform((value) => value ?? undefined),
});

const resolveContinuityAgreementResponseId = ({
  linkId,
  agreementId,
  cookies,
  requestedAgreementResponseId,
}: {
  linkId: string;
  agreementId: string;
  cookies: Record<string, string | undefined>;
  requestedAgreementResponseId?: string;
}): string | null => {
  const accessCookie = cookies[getSignedAgreementAccessCookieName(linkId)];
  const accessPayload = parseSignedAgreementAccessToken(accessCookie);
  const downloadToken = cookies[SIGNED_DOWNLOAD_COOKIE_NAME];

  const accessResponseId =
    accessPayload &&
    accessPayload.linkId === linkId &&
    accessPayload.agreementId === agreementId
      ? accessPayload.agreementResponseId
      : null;

  const downloadResponseId =
    requestedAgreementResponseId &&
    verifySignedAgreementDownloadToken(downloadToken, {
      agreementResponseId: requestedAgreementResponseId,
      linkId,
    })
      ? requestedAgreementResponseId
      : null;

  if (accessResponseId && downloadResponseId) {
    return accessResponseId === downloadResponseId ? accessResponseId : null;
  }

  if (accessResponseId) {
    return accessResponseId;
  }

  if (downloadResponseId) {
    return downloadResponseId;
  }

  if (
    requestedAgreementResponseId &&
    verifySignedAgreementAccessToken(accessCookie, {
      linkId,
      agreementId,
      agreementResponseId: requestedAgreementResponseId,
    })
  ) {
    return requestedAgreementResponseId;
  }

  return null;
};

export default async function handle(
  req: NextApiRequest,
  res: NextApiResponse,
) {
  if (req.method !== "POST") {
    res.setHeader("Allow", ["POST"]);
    return res.status(405).end(`Method ${req.method} Not Allowed`);
  }

  try {
    const parseResult = createSigningSessionSchema.safeParse(req.body);

    if (!parseResult.success) {
      throw new TeamError("A valid agreement signing request is required.");
    }

    const { agreementId, linkId, email, name, agreementResponseId } =
      parseResult.data;

    const ipAddressValue = getIpAddress(req.headers);
    // Run the independent rate-limit checks and agreement read in parallel; we still bail on a 429 before further work.
    const [linkLimit, ipLimit, agreement] = await Promise.all([
      ratelimit(100, "1 m").limit(`signing-session:${linkId}`),
      ratelimit(20, "1 m").limit(`signing-session:ip:${ipAddressValue}`),
      prisma.agreement.findFirst({
        where: {
          id: agreementId,
          deletedAt: null,
          links: {
            some: {
              id: linkId,
              deletedAt: null,
              enableAgreement: true,
            },
          },
        },
        select: {
          id: true,
          teamId: true,
          signingProvider: true,
          contentType: true,
          signingEnvelopeId: true,
          signingTemplateId: true,
          signingExternalId: true,
        },
      }),
    ]);

    if (!linkLimit.success || !ipLimit.success) {
      return res.status(429).json({
        message: "Too many signing requests. Please try again in a minute.",
      });
    }

    if (!agreement) {
      throw new TeamError("Agreement signing is not available for this link.");
    }

    if (!isSigningAgreement(agreement)) {
      throw new TeamError("This agreement does not support embedded signing.");
    }

    if (!agreement.signingEnvelopeId || !agreement.signingTemplateId) {
      throw new TeamError(
        "This agreement has not finished syncing with the signing provider yet.",
      );
    }

    const cookies = parseCookieHeader(req.headers.cookie || "");
    const continuityAgreementResponseId = resolveContinuityAgreementResponseId({
      linkId,
      agreementId,
      cookies,
      requestedAgreementResponseId: agreementResponseId,
    });

    if (continuityAgreementResponseId) {
      const existingResponse = await prisma.agreementResponse.findUnique({
        where: {
          id: continuityAgreementResponseId,
        },
        select: {
          id: true,
          agreementId: true,
          linkId: true,
          signingStatus: true,
          signingExternalId: true,
        },
      });

      if (
        existingResponse &&
        existingResponse.agreementId === agreementId &&
        existingResponse.linkId === linkId
      ) {
        if (getAgreementResponseSignedState(existingResponse.signingStatus)) {
          const accessCookie = mintSignedAgreementAccessToken({
            agreementResponseId: existingResponse.id,
            linkId,
            agreementId,
          });

          res.setHeader("Set-Cookie", [
            buildSignedAgreementAccessCookie({
              linkId,
              token: accessCookie.token,
              maxAgeSeconds: accessCookie.maxAgeSeconds,
              secure: process.env.NODE_ENV === "production",
            }),
          ]);

          return res.status(200).json({
            alreadySigned: true,
            agreementResponseId: existingResponse.id,
            signingStatus: existingResponse.signingStatus,
          });
        }

        if (!existingResponse.signingExternalId) {
          throw new TeamError(
            "Signing session is missing its external identifier.",
          );
        }

        // Direct-link signing: Documenso mints the per-visitor document at completion (stamped with this response's externalId so `/signing/complete` can bind it back), so we only persist the access-form identity here when provided.
        if (email || name) {
          await prisma.agreementResponse.update({
            where: {
              id: existingResponse.id,
            },
            data: {
              ...(email ? { signerEmail: email } : {}),
              ...(name ? { signerName: name } : {}),
            },
          });
        }

        const { token } = await getAgreementSigningToken({
          signingTemplateId: agreement.signingTemplateId,
        });

        const downloadCookie = mintSignedAgreementDownloadToken({
          agreementResponseId: existingResponse.id,
          linkId,
        });

        res.setHeader("Set-Cookie", [
          buildSignedAgreementDownloadCookie({
            token: downloadCookie.token,
            maxAgeSeconds: downloadCookie.maxAgeSeconds,
            secure: process.env.NODE_ENV === "production",
          }),
        ]);

        return res.status(200).json({
          agreementResponseId: existingResponse.id,
          externalId: existingResponse.signingExternalId,
          token,
          ...getSigningEmbedConfig(),
        });
      }
    }

    const updatedAgreementResponse = await prisma.$transaction(async (tx) => {
      const created = await tx.agreementResponse.create({
        data: {
          agreementId: agreement.id,
          linkId,
          signerEmail: email ?? null,
          signerName: name ?? null,
        },
      });

      const externalId = buildAgreementResponseSigningExternalId(
        agreement.teamId,
        created.id,
      );

      return tx.agreementResponse.update({
        where: {
          id: created.id,
        },
        data: {
          signingExternalId: externalId,
        },
        select: {
          id: true,
          signingExternalId: true,
        },
      });
    });

    if (!updatedAgreementResponse.signingExternalId) {
      throw new TeamError("Failed to initialize the signing session.");
    }

    // Direct-link signing: resolve the template's shared direct-link token; Documenso creates the per-visitor document lazily at completion (stamped with this response's externalId) so `/signing/complete` can bind it back.
    const { token } = await getAgreementSigningToken({
      signingTemplateId: agreement.signingTemplateId,
    });

    const downloadCookie = mintSignedAgreementDownloadToken({
      agreementResponseId: updatedAgreementResponse.id,
      linkId,
    });
    res.setHeader("Set-Cookie", [
      buildSignedAgreementDownloadCookie({
        token: downloadCookie.token,
        maxAgeSeconds: downloadCookie.maxAgeSeconds,
        secure: process.env.NODE_ENV === "production",
      }),
    ]);

    return res.status(200).json({
      agreementResponseId: updatedAgreementResponse.id,
      externalId: updatedAgreementResponse.signingExternalId,
      token,
      ...getSigningEmbedConfig(),
    });
  } catch (error) {
    return errorhandler(error, res);
  }
}