feat: add envelopes (#2025)

This PR is handles the changes required to support envelopes. The new
envelope editor/signing page will be hidden during release.

The core changes here is to migrate the documents and templates model to
a centralized envelopes model.

Even though Documents and Templates are removed, from the user
perspective they will still exist as we remap envelopes to documents and
templates.

apps/remix/app/utils/field-signing/dropdown-field.ts

@@ -0,0 +1,48 @@
+import { FieldType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import type { TFieldDropdown } from '@documenso/lib/types/field';
+import type { TSignEnvelopeFieldValue } from '@documenso/trpc/server/envelope-router/sign-envelope-field.types';
+
+import { SignFieldDropdownDialog } from '~/components/dialogs/sign-field-dropdown-dialog';
+
+type HandleDropdownFieldClickOptions = {
+  field: TFieldDropdown;
+  text: string | null;
+};
+
+export const handleDropdownFieldClick = async (
+  options: HandleDropdownFieldClickOptions,
+): Promise<Extract<TSignEnvelopeFieldValue, { type: typeof FieldType.DROPDOWN }> | null> => {
+  const { field, text } = options;
+
+  if (field.type !== FieldType.DROPDOWN || !field.fieldMeta) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Invalid field type',
+    });
+  }
+
+  if (field.inserted) {
+    return {
+      type: FieldType.DROPDOWN,
+      value: null,
+    };
+  }
+
+  let textToInsert = text;
+
+  if (!textToInsert) {
+    textToInsert = await SignFieldDropdownDialog.call({
+      fieldMeta: field.fieldMeta,
+    });
+  }
+
+  if (!textToInsert) {
+    return null;
+  }
+
+  return {
+    type: FieldType.DROPDOWN,
+    value: textToInsert,
+  };
+};

apps/remix/app/utils/field-signing/email-field.ts

@@ -0,0 +1,46 @@
+import { FieldType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import type { TFieldEmail } from '@documenso/lib/types/field';
+import type { TSignEnvelopeFieldValue } from '@documenso/trpc/server/envelope-router/sign-envelope-field.types';
+
+import { SignFieldEmailDialog } from '~/components/dialogs/sign-field-email-dialog';
+
+type HandleEmailFieldClickOptions = {
+  field: TFieldEmail;
+  email: string | null;
+};
+
+export const handleEmailFieldClick = async (
+  options: HandleEmailFieldClickOptions,
+): Promise<Extract<TSignEnvelopeFieldValue, { type: typeof FieldType.EMAIL }> | null> => {
+  const { field, email } = options;
+
+  if (field.type !== FieldType.EMAIL) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Invalid field type',
+    });
+  }
+
+  if (field.inserted) {
+    return {
+      type: FieldType.EMAIL,
+      value: null,
+    };
+  }
+
+  let emailToInsert = email;
+
+  if (!emailToInsert) {
+    emailToInsert = await SignFieldEmailDialog.call({});
+  }
+
+  if (!emailToInsert) {
+    return null;
+  }
+
+  return {
+    type: FieldType.EMAIL,
+    value: emailToInsert,
+  };
+};

apps/remix/app/utils/field-signing/initial-field.ts

@@ -0,0 +1,46 @@
+import { FieldType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import type { TFieldInitials } from '@documenso/lib/types/field';
+import type { TSignEnvelopeFieldValue } from '@documenso/trpc/server/envelope-router/sign-envelope-field.types';
+
+import { SignFieldInitialsDialog } from '~/components/dialogs/sign-field-initials-dialog';
+
+type HandleInitialsFieldClickOptions = {
+  field: TFieldInitials;
+  initials: string | null;
+};
+
+export const handleInitialsFieldClick = async (
+  options: HandleInitialsFieldClickOptions,
+): Promise<Extract<TSignEnvelopeFieldValue, { type: typeof FieldType.INITIALS }> | null> => {
+  const { field, initials } = options;
+
+  if (field.type !== FieldType.INITIALS) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Invalid field type',
+    });
+  }
+
+  if (field.inserted) {
+    return {
+      type: FieldType.INITIALS,
+      value: null,
+    };
+  }
+
+  let initialsToInsert = initials;
+
+  if (!initialsToInsert) {
+    initialsToInsert = await SignFieldInitialsDialog.call({});
+  }
+
+  if (!initialsToInsert) {
+    return null;
+  }
+
+  return {
+    type: FieldType.INITIALS,
+    value: initials,
+  };
+};

apps/remix/app/utils/field-signing/name-field.ts

@@ -0,0 +1,48 @@
+import { FieldType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import type { TFieldName } from '@documenso/lib/types/field';
+import type { TSignEnvelopeFieldValue } from '@documenso/trpc/server/envelope-router/sign-envelope-field.types';
+
+import { SignFieldNameDialog } from '~/components/dialogs/sign-field-name-dialog';
+
+type HandleNameFieldClickOptions = {
+  field: TFieldName;
+  name: string | null;
+};
+
+export const handleNameFieldClick = async (
+  options: HandleNameFieldClickOptions,
+): Promise<Extract<TSignEnvelopeFieldValue, { type: typeof FieldType.NAME }> | null> => {
+  const { field, name } = options;
+
+  if (field.type !== FieldType.NAME) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Invalid field type',
+    });
+  }
+
+  if (field.inserted) {
+    return {
+      type: FieldType.NAME,
+      value: null,
+    };
+  }
+
+  let nameToInsert = name;
+
+  if (!nameToInsert) {
+    nameToInsert = await SignFieldNameDialog.call({
+      // Props here.
+    });
+  }
+
+  if (!nameToInsert) {
+    return null;
+  }
+
+  return {
+    type: FieldType.NAME,
+    value: nameToInsert,
+  };
+};

apps/remix/app/utils/field-signing/number-field.ts

@@ -0,0 +1,48 @@
+import { FieldType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import type { TFieldNumber } from '@documenso/lib/types/field';
+import type { TSignEnvelopeFieldValue } from '@documenso/trpc/server/envelope-router/sign-envelope-field.types';
+
+import { SignFieldNumberDialog } from '~/components/dialogs/sign-field-number-dialog';
+
+type HandleNumberFieldClickOptions = {
+  field: TFieldNumber;
+  number: number | null;
+};
+
+export const handleNumberFieldClick = async (
+  options: HandleNumberFieldClickOptions,
+): Promise<Extract<TSignEnvelopeFieldValue, { type: typeof FieldType.NUMBER }> | null> => {
+  const { field, number } = options;
+
+  if (field.type !== FieldType.NUMBER) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Invalid field type',
+    });
+  }
+
+  if (field.inserted) {
+    return {
+      type: FieldType.NUMBER,
+      value: null,
+    };
+  }
+
+  let numberToInsert = number;
+
+  if (!numberToInsert) {
+    numberToInsert = await SignFieldNumberDialog.call({
+      fieldMeta: field.fieldMeta,
+    });
+  }
+
+  if (!numberToInsert) {
+    return null;
+  }
+
+  return {
+    type: FieldType.NUMBER,
+    value: numberToInsert,
+  };
+};

apps/remix/app/utils/field-signing/signature-field.ts

@@ -0,0 +1,56 @@
+import { FieldType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import type { TFieldSignature } from '@documenso/lib/types/field';
+import type { TSignEnvelopeFieldValue } from '@documenso/trpc/server/envelope-router/sign-envelope-field.types';
+
+import { SignFieldSignatureDialog } from '~/components/dialogs/sign-field-signature-dialog';
+
+type HandleSignatureFieldClickOptions = {
+  field: TFieldSignature;
+  signature: string | null;
+  typedSignatureEnabled?: boolean;
+  uploadSignatureEnabled?: boolean;
+  drawSignatureEnabled?: boolean;
+};
+
+export const handleSignatureFieldClick = async (
+  options: HandleSignatureFieldClickOptions,
+): Promise<Extract<TSignEnvelopeFieldValue, { type: typeof FieldType.SIGNATURE }> | null> => {
+  const { field, signature, typedSignatureEnabled, uploadSignatureEnabled, drawSignatureEnabled } =
+    options;
+
+  if (field.type !== FieldType.SIGNATURE) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Invalid field type',
+    });
+  }
+
+  if (field.inserted) {
+    return {
+      type: FieldType.SIGNATURE,
+      value: null,
+      isBase64: false,
+    };
+  }
+
+  let signatureToInsert = signature;
+
+  if (!signatureToInsert) {
+    signatureToInsert = await SignFieldSignatureDialog.call({
+      typedSignatureEnabled,
+      uploadSignatureEnabled,
+      drawSignatureEnabled,
+    });
+  }
+
+  if (!signatureToInsert) {
+    return null;
+  }
+
+  return {
+    type: FieldType.SIGNATURE,
+    value: signatureToInsert,
+    isBase64: signatureToInsert.startsWith('data:image'),
+  };
+};

apps/remix/app/utils/field-signing/text-field.ts

@@ -0,0 +1,48 @@
+import { FieldType } from '@prisma/client';
+
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
+import type { TFieldText } from '@documenso/lib/types/field';
+import type { TSignEnvelopeFieldValue } from '@documenso/trpc/server/envelope-router/sign-envelope-field.types';
+
+import { SignFieldTextDialog } from '~/components/dialogs/sign-field-text-dialog';
+
+type HandleTextFieldClickOptions = {
+  field: TFieldText;
+  text: string | null;
+};
+
+export const handleTextFieldClick = async (
+  options: HandleTextFieldClickOptions,
+): Promise<Extract<TSignEnvelopeFieldValue, { type: typeof FieldType.TEXT }> | null> => {
+  const { field, text } = options;
+
+  if (field.type !== FieldType.TEXT) {
+    throw new AppError(AppErrorCode.INVALID_REQUEST, {
+      message: 'Invalid field type',
+    });
+  }
+
+  if (field.inserted) {
+    return {
+      type: FieldType.TEXT,
+      value: null,
+    };
+  }
+
+  let textToInsert = text;
+
+  if (!textToInsert) {
+    textToInsert = await SignFieldTextDialog.call({
+      fieldMeta: field.fieldMeta,
+    });
+  }
+
+  if (!textToInsert) {
+    return null;
+  }
+
+  return {
+    type: FieldType.TEXT,
+    value: textToInsert,
+  };
+};