Skip to content

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

27.0 KB
Raw Blame
import { Prisma } from "@prisma/client";
import { waitUntil } from "@vercel/functions";
import crypto from "crypto";
import { z } from "zod";

import { TeamError } from "@/lib/errorHandler";
import prisma from "@/lib/prisma";

import {
  getSigningClient,
  getSigningHost,
  getSigningWebhookSecret,
} from "./client";
import { getEnvelope } from "./envelopes";

export const SIGNING_PROVIDER_SCHEMA = z.enum(["LEGACY", "DOCUMENSO"]);
export const SIGNING_STATUS_SCHEMA = z.enum([
  "PENDING",
  "SIGNED",
  "COMPLETED",
  "FAILED",
]);

export type SigningProvider = z.infer<typeof SIGNING_PROVIDER_SCHEMA>;
export type SigningStatus = z.infer<typeof SIGNING_STATUS_SCHEMA>;

const SIGNING_TEMPLATE_ID_SCHEMA = z.coerce.number().int().positive();

export const buildAgreementSigningExternalId = (
  teamId: string,
  agreementId: string,
) => {
  return `papermark:team:${teamId}:agreement:${agreementId}`;
};

export const buildAgreementResponseSigningExternalId = (
  teamId: string,
  agreementResponseId: string,
) => {
  return `papermark:team:${teamId}:agreement-response:${agreementResponseId}`;
};

export const isSigningAgreement = ({
  signingProvider,
  contentType,
}: {
  signingProvider?: string | null;
  contentType?: string | null;
}) => {
  const provider = SIGNING_PROVIDER_SCHEMA.safeParse(signingProvider);

  return (
    (provider.success && provider.data === "DOCUMENSO") ||
    contentType === "SIGNING"
  );
};

export const getAgreementResponseSignedState = (
  signingStatus?: string | null,
) => {
  const parsedStatus = SIGNING_STATUS_SCHEMA.safeParse(signingStatus);

  if (!parsedStatus.success) {
    return false;
  }

  return parsedStatus.data === "SIGNED" || parsedStatus.data === "COMPLETED";
};

export const normalizeSignerEmail = (email?: string | null) => {
  if (typeof email !== "string") {
    return null;
  }

  const trimmed = email.trim().toLowerCase();
  return trimmed.length > 0 ? trimmed : null;
};

export const normalizeSignerName = (name?: string | null) => {
  if (typeof name !== "string") {
    return null;
  }

  const trimmed = name.trim();
  return trimmed.length > 0 ? trimmed : null;
};

const assertAgreementResponseSignerIdentity = ({
  agreementResponse,
  signerEmail,
  signerName,
  requireSignerEmail,
  requireSignerName,
}: {
  agreementResponse: {
    signerEmail: string | null;
    signerName: string | null;
  };
  signerEmail?: string | null;
  signerName?: string | null;
  requireSignerEmail?: boolean;
  requireSignerName?: boolean;
}) => {
  const submittedEmail = normalizeSignerEmail(signerEmail);
  const storedEmail = normalizeSignerEmail(agreementResponse.signerEmail);

  if (requireSignerEmail && !submittedEmail) {
    throw new TeamError(
      "Agreement signing could not be verified for this link.",
    );
  }

  if (storedEmail) {
    if (!submittedEmail || submittedEmail !== storedEmail) {
      throw new TeamError(
        "Agreement signing could not be verified for this link.",
      );
    }
  }

  const submittedName = normalizeSignerName(signerName);
  const storedName = normalizeSignerName(agreementResponse.signerName);

  if (requireSignerName && !submittedName) {
    throw new TeamError(
      "Agreement signing could not be verified for this link.",
    );
  }

  if (storedName && submittedName && submittedName !== storedName) {
    throw new TeamError(
      "Agreement signing could not be verified for this link.",
    );
  }
};

export const verifySigningWebhookSecret = (
  secret?: string | null,
): { ok: boolean; configured: boolean } => {
  const expectedSecret = getSigningWebhookSecret();

  if (!expectedSecret) {
    return { ok: false, configured: false };
  }

  if (!secret || secret.length !== expectedSecret.length) {
    return { ok: false, configured: true };
  }

  const ok = crypto.timingSafeEqual(
    Buffer.from(secret),
    Buffer.from(expectedSecret),
  );

  return { ok, configured: true };
};

export const SIGNING_TEMPLATE_VIEWER_RECIPIENT_NAME = "Viewer";

export const buildSigningTemplateViewerRecipient = () => ({
  email: "" as const,
  name: SIGNING_TEMPLATE_VIEWER_RECIPIENT_NAME,
  role: "SIGNER" as const,
  signingOrder: 1,
});

type SigningTemplateRecipient = {
  id: number;
  email?: string | null;
  name?: string | null;
  role?: string | null;
  signingOrder?: number | null;
};

const isSigningTemplateViewerRecipient = (
  recipient: SigningTemplateRecipient,
) =>
  recipient.name === SIGNING_TEMPLATE_VIEWER_RECIPIENT_NAME &&
  recipient.role === "SIGNER";

const findSigningTemplateViewerRecipient = <
  T extends SigningTemplateRecipient,
>(
  recipients: T[],
) =>
  recipients.find(isSigningTemplateViewerRecipient) ??
  recipients.find((recipient) => recipient.role === "SIGNER") ??
  recipients[0];

const recipientNeedsViewerNormalization = (
  recipient: SigningTemplateRecipient,
) =>
  recipient.email !== "" ||
  recipient.name !== SIGNING_TEMPLATE_VIEWER_RECIPIENT_NAME ||
  recipient.role !== "SIGNER" ||
  recipient.signingOrder !== 1;

/** Reset the template recipient to the anonymous "Viewer" placeholder by its id (not a replacement) so existing fields stay attached. */
export const ensureSigningTemplateViewerRecipient = async ({
  envelopeId,
}: {
  envelopeId: string;
}) => {
  const signingClient = getSigningClient();
  const envelope = await getEnvelope(envelopeId);

  if (envelope.type !== "TEMPLATE") {
    throw new TeamError(
      "Signing envelopes must be templates before recipient setup can be checked.",
    );
  }

  const recipient = findSigningTemplateViewerRecipient(envelope.recipients);

  if (!recipient) {
    await signingClient.envelopes.recipients.createMany({
      envelopeId,
      data: [buildSigningTemplateViewerRecipient()],
    });
    return getEnvelope(envelopeId);
  }

  if (recipientNeedsViewerNormalization(recipient)) {
    await signingClient.envelopes.recipients.updateMany({
      envelopeId,
      data: [
        {
          id: recipient.id,
          ...buildSigningTemplateViewerRecipient(),
        },
      ],
    });
    return getEnvelope(envelopeId);
  }

  return envelope;
};

/** Create a Documenso template and seed the placeholder "Viewer" signer via the envelope side (email "" = Unknown enum); the direct link is minted later by `/signing/sync`. */
export const createSigningTemplateEnvelope = async ({
  title,
  externalId,
  file,
  folderId,
}: {
  title: string;
  externalId: string;
  file: {
    fileName: string;
    content: Uint8Array;
  };
  folderId?: string | null;
}) => {
  const signingClient = getSigningClient();

  const template = await signingClient.templates.create({
    payload: {
      title,
      externalId,
      folderId: folderId || undefined,
      meta: {
        subject: title,
        distributionMethod: "NONE",
        emailSettings: {
          recipientSigningRequest: false,
          recipientRemoved: false,
          recipientSigned: false,
          documentPending: false,
          documentCompleted: false,
          documentDeleted: false,
          ownerDocumentCompleted: false,
          ownerRecipientExpired: false,
          ownerDocumentCreated: false,
        },
      },
    },
    file: {
      fileName: file.fileName,
      content: file.content,
    },
  });

  await signingClient.envelopes.recipients.createMany({
    envelopeId: template.envelopeId,
    data: [buildSigningTemplateViewerRecipient()],
  });

  return template;
};

const parseNumericTemplateId = (signingTemplateId: string) => {
  const parsed = SIGNING_TEMPLATE_ID_SCHEMA.safeParse(signingTemplateId);
  if (!parsed.success) {
    throw new TeamError(
      "The signing template id is invalid; please re-upload the agreement.",
    );
  }
  return parsed.data;
};

/** Idempotently ensure a template's direct link exists (re-enable or mint), keyed by the numeric `templateId` read from our DB since it isn't on the V2 envelope. */
export const ensureSigningTemplateDirectLink = async ({
  signingTemplateId,
}: {
  signingTemplateId: string;
}) => {
  const numericTemplateId = parseNumericTemplateId(signingTemplateId);
  const signingClient = getSigningClient();
  const template = await signingClient.templates.get({
    templateId: numericTemplateId,
  });

  if (template.directLink?.enabled && template.directLink.token) {
    return { template, directLink: template.directLink };
  }

  if (template.directLink?.token) {
    const directLink = await signingClient.templates.directLink.toggle({
      templateId: numericTemplateId,
      enabled: true,
    });
    return { template, directLink };
  }

  const signerRecipient = findSigningTemplateViewerRecipient(
    template.recipients,
  );
  if (!signerRecipient) {
    throw new TeamError(
      "The signing template must include at least one recipient before a direct link can be created.",
    );
  }

  try {
    const directLink = await signingClient.templates.directLink.create({
      templateId: numericTemplateId,
      directRecipientId: signerRecipient.id,
    });
    return { template, directLink };
  } catch (error) {
    console.error(
      "[signing] templates.directLink.create failed",
      {
        templateId: numericTemplateId,
        directRecipientId: signerRecipient.id,
      },
      error,
    );
    throw error;
  }
};

/** Delete (not just toggle off) the direct link so the V2 field editor doesn't fail on "direct template exists"; `/signing/sync` recreates it after save. */
export const deleteSigningTemplateDirectLink = async ({
  signingTemplateId,
}: {
  signingTemplateId: string;
}) => {
  const numericTemplateId = parseNumericTemplateId(signingTemplateId);
  const signingClient = getSigningClient();
  const template = await signingClient.templates.get({
    templateId: numericTemplateId,
  });

  if (!template.directLink) {
    return { template, directLink: template.directLink ?? null };
  }

  const directLink = await signingClient.templates.directLink.delete({
    templateId: numericTemplateId,
  });

  return { template, directLink };
};

const DEFAULT_SIGNING_FOLDER_NAME = "Papermark";

const buildTeamSigningFolderTag = (teamId: string) =>
  `papermark:team:${teamId}`;

export const buildTeamSigningFolderName = ({
  name,
  id,
}: {
  name?: string | null;
  id: string;
}) => {
  const trimmedName = name?.trim();
  const tag = buildTeamSigningFolderTag(id);
  const prefix =
    trimmedName && trimmedName.length > 0
      ? trimmedName
      : DEFAULT_SIGNING_FOLDER_NAME;

  return `${prefix} [${tag}]`;
};

const folderHasTeamTag = (folderName: string, teamId: string) =>
  folderName.includes(`[${buildTeamSigningFolderTag(teamId)}]`);

const findTeamSigningFolderId = async ({
  teamId,
  type,
}: {
  teamId: string;
  type: "TEMPLATE" | "DOCUMENT";
}) => {
  const signingClient = getSigningClient();
  const tag = buildTeamSigningFolderTag(teamId);

  let currentPage = 1;
  let totalPages = 1;

  while (currentPage <= totalPages) {
    const folders = await signingClient.folders.find({
      query: tag,
      type,
      page: currentPage,
      perPage: 100,
    });

    const match = folders.data.find((folder) =>
      folderHasTeamTag(folder.name, teamId),
    );

    if (match) {
      return match.id;
    }

    totalPages = folders.totalPages;
    currentPage += 1;
  }

  return null;
};

const ensureTeamSigningFolderByType = async ({
  team,
  type,
}: {
  team: { id: string; name?: string | null };
  type: "TEMPLATE" | "DOCUMENT";
}) => {
  const existingFolderId = await findTeamSigningFolderId({
    teamId: team.id,
    type,
  });

  if (existingFolderId) {
    return existingFolderId;
  }

  const signingClient = getSigningClient();
  const folder = await signingClient.folders.create({
    name: buildTeamSigningFolderName({ name: team.name, id: team.id }),
    type,
  });

  return folder.id;
};

type TeamSigningFolders = {
  templateFolderId: string;
  documentFolderId: string;
};

const TEAM_SIGNING_FOLDER_CACHE_TTL_MS = 5 * 60 * 1000;

const teamSigningFolderCache = new Map<
  string,
  { folders: TeamSigningFolders; expiresAt: number }
>();

export const ensureTeamSigningFolders = async (
  teamId: string,
): Promise<TeamSigningFolders> => {
  const cached = teamSigningFolderCache.get(teamId);

  if (cached && cached.expiresAt > Date.now()) {
    return cached.folders;
  }

  const team = await prisma.team.findUnique({
    where: {
      id: teamId,
    },
    select: {
      id: true,
      name: true,
    },
  });

  if (!team) {
    throw new TeamError("Team not found while preparing signing folders.");
  }

  const [templateFolderId, documentFolderId] = await Promise.all([
    ensureTeamSigningFolderByType({ team, type: "TEMPLATE" }),
    ensureTeamSigningFolderByType({ team, type: "DOCUMENT" }),
  ]);

  const folders: TeamSigningFolders = {
    templateFolderId,
    documentFolderId,
  };

  teamSigningFolderCache.set(teamId, {
    folders,
    expiresAt: Date.now() + TEAM_SIGNING_FOLDER_CACHE_TTL_MS,
  });

  return folders;
};

/** Resolve an agreement's direct-link token, keyed by the numeric `templateId` from our DB (the envelope only carries it for DOCUMENT envelopes). */
export const getAgreementSigningToken = async ({
  signingTemplateId,
}: {
  signingTemplateId: string;
}) => {
  const { template, directLink } = await ensureSigningTemplateDirectLink({
    signingTemplateId,
  });

  return {
    token: directLink.token,
    templateId: String(template.id),
    directLinkId: directLink.id,
  };
};

export type SigningDocumentSession = {
  documentId: number;
  envelopeId: string;
  recipientId: number;
  token: string;
};

/** Mint a per-visitor document via `templates.use` (EmbedSignDocument) so fields render inline; `distributionMethod: "NONE"` sends no email and `externalId` ties it back to the AgreementResponse. */
export const createSigningDocumentFromTemplate = async ({
  signingTemplateId,
  externalId,
  signerEmail,
  signerName,
}: {
  signingTemplateId: string;
  externalId: string;
  signerEmail?: string | null;
  signerName?: string | null;
}): Promise<SigningDocumentSession> => {
  const numericTemplateId = parseNumericTemplateId(signingTemplateId);
  const signingClient = getSigningClient();

  // Fields are drawn against the single "Viewer" recipient seeded at setup
  // time; `templates.use` maps this visitor onto that placeholder by its id.
  const template = await signingClient.templates.get({
    templateId: numericTemplateId,
  });

  const viewerRecipient = findSigningTemplateViewerRecipient(
    template.recipients,
  );
  if (!viewerRecipient) {
    throw new TeamError(
      "The signing template has no recipient to assign the signer to.",
    );
  }

  const document = await signingClient.templates.use({
    templateId: numericTemplateId,
    externalId,
    distributeDocument: true,
    recipients: [
      {
        id: viewerRecipient.id,
        email: normalizeSignerEmail(signerEmail) ?? "",
        name: normalizeSignerName(signerName) ?? undefined,
      },
    ],
    override: {
      distributionMethod: "NONE",
    },
  });

  const recipient =
    document.recipients.find((item) => item.token) ?? document.recipients[0];

  if (!recipient?.token) {
    throw new TeamError(
      "Documenso did not return a signing token for the created document.",
    );
  }

  return {
    documentId: document.id,
    envelopeId: document.envelopeId,
    recipientId: recipient.id,
    token: recipient.token,
  };
};

/** Re-fetch the token for an existing per-visitor document so re-opening reuses it instead of spawning a new one; returns null when it's no longer signable. */
export const getReusableSigningDocumentSession = async ({
  documentId,
}: {
  documentId: number;
}): Promise<SigningDocumentSession | null> => {
  const signingClient = getSigningClient();

  try {
    const document = await signingClient.documents.get({ documentId });

    if (document.status === "COMPLETED" || document.status === "REJECTED") {
      return null;
    }

    const recipient =
      document.recipients.find((item) => item.token) ?? document.recipients[0];

    if (!recipient?.token) {
      return null;
    }

    return {
      documentId,
      envelopeId: recipient.envelopeId,
      recipientId: recipient.id,
      token: recipient.token,
    };
  } catch (error) {
    console.error("[signing] failed to reuse signing document", {
      documentId,
      error,
    });
    return null;
  }
};

/** Resolve a signable document session: reuse the response's pending document when possible, otherwise create one from the template. */
export const ensureSigningDocumentSession = async ({
  signingTemplateId,
  externalId,
  existingDocumentId,
  signerEmail,
  signerName,
}: {
  signingTemplateId: string;
  externalId: string;
  existingDocumentId?: number | null;
  signerEmail?: string | null;
  signerName?: string | null;
}): Promise<SigningDocumentSession> => {
  if (existingDocumentId) {
    const reused = await getReusableSigningDocumentSession({
      documentId: existingDocumentId,
    });

    if (reused) {
      return reused;
    }
  }

  return createSigningDocumentFromTemplate({
    signingTemplateId,
    externalId,
    signerEmail,
    signerName,
  });
};

export const getSignedDocumentDetails = async (documentId: number) => {
  const signingClient = getSigningClient();
  const document = await signingClient.documents.get({ documentId });

  const signedRecipient =
    document.recipients.find(
      (recipient) => recipient.signingStatus === "SIGNED",
    ) || document.recipients[0];

  return {
    document,
    signedRecipient,
  };
};

const moveSigningDocumentToTeamFolder = async ({
  documentId,
  currentFolderId,
  teamId,
}: {
  documentId: number;
  currentFolderId: string | null | undefined;
  teamId: string;
}) => {
  try {
    const { documentFolderId } = await ensureTeamSigningFolders(teamId);

    if (!documentFolderId || currentFolderId === documentFolderId) {
      return;
    }

    const signingClient = getSigningClient();

    await signingClient.documents.update({
      documentId,
      data: {
        folderId: documentFolderId,
      },
    });
  } catch (error) {
    // Folder placement is best-effort: never block status sync on it.
    console.error(
      "[signing] Failed to move signed document into the team folder.",
      error,
    );
  }
};

export const syncAgreementResponseWithSigningDocument = async ({
  agreementResponseId,
  documentId,
  signingStatus,
}: {
  agreementResponseId: string;
  documentId: number;
  signingStatus?: SigningStatus;
}) => {
  // Callers of `/signing/complete` are unauthenticated, so enforce the
  // document <-> response binding below (these reads are independent, run in parallel).
  const [existingResponse, signedDetails] = await Promise.all([
    prisma.agreementResponse.findUnique({
      where: { id: agreementResponseId },
      select: {
        id: true,
        signingExternalId: true,
        signingStatus: true,
        agreement: {
          select: {
            id: true,
            teamId: true,
            signingEnvelopeId: true,
            signingTemplateId: true,
          },
        },
      },
    }),
    getSignedDocumentDetails(documentId),
  ]);

  if (!existingResponse) {
    throw new TeamError("Agreement signing session was not found.");
  }

  const { document, signedRecipient } = signedDetails;

  // Document <-> session binding: the document must carry the externalId we
  // minted for this response, and it must belong to the agreement template.
  if (
    !existingResponse.signingExternalId ||
    document.externalId !== existingResponse.signingExternalId
  ) {
    throw new TeamError(
      "Signed document does not belong to this signing session.",
    );
  }

  // Signing spawns a new DOCUMENT envelope, so template membership is verified
  // via `document.templateId === agreement.signingTemplateId`, not envelopeId.
  if (existingResponse.agreement?.signingTemplateId) {
    const parsedTemplateId = SIGNING_TEMPLATE_ID_SCHEMA.safeParse(
      existingResponse.agreement.signingTemplateId,
    );

    if (
      parsedTemplateId.success &&
      document.templateId &&
      document.templateId !== parsedTemplateId.data
    ) {
      throw new TeamError(
        "Signed document does not belong to this agreement template.",
      );
    }
  }

  const recipientEmail = signedRecipient?.email?.trim();
  const recipientName = signedRecipient?.name?.trim();

  const agreementResponse = await prisma.agreementResponse.update({
    where: {
      id: agreementResponseId,
    },
    data: {
      signingStatus:
        signingStatus || (document.completedAt ? "COMPLETED" : "SIGNED"),
      signingEnvelopeId: document.envelopeId,
      // Persist the numeric documentId so each download is a single keyed Documenso call.
      signingDocumentId: documentId,
      signedAt: signedRecipient?.signedAt
        ? new Date(signedRecipient.signedAt)
        : null,
      completedAt: document.completedAt ? new Date(document.completedAt) : null,
      // Overwrite the seeded identity with the provider's authoritative value, but only when present so we don't clobber it with an empty string.
      ...(recipientEmail ? { signerEmail: recipientEmail } : {}),
      ...(recipientName ? { signerName: recipientName } : {}),
    },
    include: {
      agreement: {
        select: {
          teamId: true,
        },
      },
    },
  });

  // Best-effort folder move via `waitUntil` so it survives past the response on serverless runtimes that freeze after responding.
  if (agreementResponse.agreement?.teamId) {
    waitUntil(
      moveSigningDocumentToTeamFolder({
        documentId,
        currentFolderId: document.folderId,
        teamId: agreementResponse.agreement.teamId,
      }).catch((error) => {
        console.error("[signing] background folder move failed", error);
      }),
    );
  }

  return agreementResponse;
};

export const findAgreementResponseByExternalId = async (
  signingExternalId: string,
) => {
  return prisma.agreementResponse.findUnique({
    where: {
      signingExternalId,
    },
    include: {
      agreement: {
        select: {
          id: true,
          teamId: true,
          signingProvider: true,
        },
      },
    },
  });
};

export const getAgreementResponseForAccess = async ({
  agreementResponseId,
  agreementId,
  linkId,
  signerEmail,
  signerName,
  requireSignerEmail,
  requireSignerName,
  skipSignerIdentityCheck,
}: {
  agreementResponseId?: string | null;
  agreementId?: string | null;
  linkId?: string | null;
  signerEmail?: string | null;
  signerName?: string | null;
  requireSignerEmail?: boolean;
  requireSignerName?: boolean;
  // Set when an HMAC-bound cookie (`pm_sas_{linkId}`) already proves browser ownership — stronger than an email/name match.
  skipSignerIdentityCheck?: boolean;
}) => {
  if (!agreementResponseId || !agreementId) {
    throw new TeamError("Agreement signing is required before continuing.");
  }

  const agreementResponse = await prisma.agreementResponse.findUnique({
    where: {
      id: agreementResponseId,
    },
  });

  if (!agreementResponse || agreementResponse.agreementId !== agreementId) {
    throw new TeamError(
      "Agreement signing could not be verified for this link.",
    );
  }

  // C3: prevent replaying a response against a different link reusing the same agreement (legacy rows without a linkId fall through).
  if (
    linkId &&
    agreementResponse.linkId &&
    agreementResponse.linkId !== linkId
  ) {
    throw new TeamError(
      "Agreement signing could not be verified for this link.",
    );
  }

  if (!getAgreementResponseSignedState(agreementResponse.signingStatus)) {
    throw new TeamError(
      "Agreement signing is still pending. Please finish signing to continue.",
    );
  }

  if (!skipSignerIdentityCheck) {
    assertAgreementResponseSignerIdentity({
      agreementResponse,
      signerEmail,
      signerName,
      requireSignerEmail,
      requireSignerName,
    });
  }

  return agreementResponse;
};

export const getSignedAgreementResponseForViewer = async ({
  agreementResponseId,
  agreementId,
  linkId,
}: {
  agreementResponseId: string;
  agreementId: string;
  linkId: string;
}) => {
  const agreementResponse = await prisma.agreementResponse.findUnique({
    where: {
      id: agreementResponseId,
    },
    select: {
      id: true,
      agreementId: true,
      linkId: true,
      signerEmail: true,
      signerName: true,
      signingStatus: true,
    },
  });

  if (
    !agreementResponse ||
    agreementResponse.agreementId !== agreementId ||
    agreementResponse.linkId !== linkId ||
    !getAgreementResponseSignedState(agreementResponse.signingStatus)
  ) {
    return null;
  }

  return agreementResponse;
};

/** Resolve the response gating access: SIGNING agreements need a pre-created SIGNED/COMPLETED response; legacy checkbox agreements get a SIGNED response created inline. */
export const ensureAgreementResponseForAccess = async ({
  agreement,
  linkId,
  agreementResponseId,
  hasConfirmedAgreement,
  signerEmail,
  signerName,
  requireSignerEmail,
  requireSignerName,
  skipSignerIdentityCheck,
}: {
  agreement: {
    id: string;
    signingProvider?: string | null;
    contentType?: string | null;
    requireName?: boolean | null;
  };
  linkId: string;
  agreementResponseId?: string | null;
  hasConfirmedAgreement?: boolean | null;
  signerEmail?: string | null;
  signerName?: string | null;
  requireSignerEmail?: boolean;
  requireSignerName?: boolean;
  skipSignerIdentityCheck?: boolean;
}) => {
  if (isSigningAgreement(agreement)) {
    return getAgreementResponseForAccess({
      agreementResponseId,
      agreementId: agreement.id,
      linkId,
      signerEmail,
      signerName,
      requireSignerEmail,
      requireSignerName:
        requireSignerName ?? agreement.requireName ?? undefined,
      skipSignerIdentityCheck,
    });
  }

  if (!hasConfirmedAgreement) {
    throw new TeamError("Agreement to NDA is required.");
  }

  const trimmedEmail =
    typeof signerEmail === "string" && signerEmail.trim().length > 0
      ? signerEmail.trim()
      : null;
  const trimmedName =
    typeof signerName === "string" && signerName.trim().length > 0
      ? signerName.trim()
      : null;

  const now = new Date();

  return prisma.agreementResponse.create({
    data: {
      agreementId: agreement.id,
      linkId,
      signerEmail: trimmedEmail,
      signerName: trimmedName,
      signingStatus: "SIGNED",
      signedAt: now,
      completedAt: now,
    },
  });
};

export const getSigningAgreementCreateData = ({
  teamId,
  name,
  content,
  contentType,
  requireName,
}: {
  teamId: string;
  name: string;
  content?: string;
  contentType: "LINK" | "TEXT" | "SIGNING";
  requireName: boolean;
}): Prisma.AgreementCreateInput => {
  const trimmedName = name.trim();

  if (contentType === "SIGNING") {
    return {
      team: {
        connect: {
          id: teamId,
        },
      },
      name: trimmedName,
      content:
        content?.trim() ||
        `Embedded signing flow for ${trimmedName}. This agreement is managed in Papermark.`,
      contentType,
      signingProvider: "DOCUMENSO",
      requireName,
    };
  }

  return {
    team: {
      connect: {
        id: teamId,
      },
    },
    name: trimmedName,
    content: content?.trim() || "",
    contentType,
    signingProvider: "LEGACY",
    requireName,
  };
};

export const getSigningEmbedConfig = () => {
  return {
    host: getSigningHost(),
  };
};