chore: remove same email check from backend

packages/api/v1/schema.ts

@@ -259,23 +259,13 @@ export type TCreateDocumentFromTemplateMutationResponseSchema = z.infer<
 export const ZGenerateDocumentFromTemplateMutationSchema = z.object({
   title: z.string().optional(),
   externalId: z.string().optional(),
-  recipients: z
+  recipients: z.array(
-    .array(
     z.object({
       id: z.number(),
       email: z.string().email(),
       name: z.string().optional(),
       signingOrder: z.number().optional(),
     }),
-    )
-    .refine(
-      (schema) => {
-        const emails = schema.map((signer) => signer.email.toLowerCase());
-        const ids = schema.map((signer) => signer.id);
-
-        return new Set(emails).size === emails.length && new Set(ids).size === ids.length;
-      },
-      { message: 'Recipient IDs and emails must be unique' },
   ),
   meta: z
     .object({

packages/trpc/server/document-router/schema.ts

@@ -192,14 +192,6 @@ export const ZCreateDocumentV2RequestSchema = z.object({
           .optional(),
       }),
     )
-    .refine(
-      (recipients) => {
-        const emails = recipients.map((recipient) => recipient.email);
-
-        return new Set(emails).size === emails.length;
-      },
-      { message: 'Recipients must have unique emails' },
-    )
     .optional(),
   meta: z
     .object({

packages/trpc/server/recipient-router/schema.ts

@@ -49,16 +49,7 @@ export const ZCreateDocumentRecipientResponseSchema = ZRecipientLiteSchema;
 
 export const ZCreateDocumentRecipientsRequestSchema = z.object({
   documentId: z.number(),
-  recipients: z.array(ZCreateRecipientSchema).refine(
+  recipients: z.array(ZCreateRecipientSchema),
-    (recipients) => {
-      const emails = recipients.map((recipient) => recipient.email.toLowerCase());
-
-      return new Set(emails).size === emails.length;
-    },
-    {
-      message: 'Recipients must have unique emails',
-    },
-  ),
 });
 
 export const ZCreateDocumentRecipientsResponseSchema = z.object({
@@ -74,18 +65,7 @@ export const ZUpdateDocumentRecipientResponseSchema = ZRecipientSchema;
 
 export const ZUpdateDocumentRecipientsRequestSchema = z.object({
   documentId: z.number(),
-  recipients: z.array(ZUpdateRecipientSchema).refine(
+  recipients: z.array(ZUpdateRecipientSchema),
-    (recipients) => {
-      const emails = recipients
-        .filter((recipient) => recipient.email !== undefined)
-        .map((recipient) => recipient.email?.toLowerCase());
-
-      return new Set(emails).size === emails.length;
-    },
-    {
-      message: 'Recipients must have unique emails',
-    },
-  ),
 });
 
 export const ZUpdateDocumentRecipientsResponseSchema = z.object({
@@ -123,16 +103,7 @@ export const ZCreateTemplateRecipientResponseSchema = ZRecipientLiteSchema;
 
 export const ZCreateTemplateRecipientsRequestSchema = z.object({
   templateId: z.number(),
-  recipients: z.array(ZCreateRecipientSchema).refine(
+  recipients: z.array(ZCreateRecipientSchema),
-    (recipients) => {
-      const emails = recipients.map((recipient) => recipient.email);
-
-      return new Set(emails).size === emails.length;
-    },
-    {
-      message: 'Recipients must have unique emails',
-    },
-  ),
 });
 
 export const ZCreateTemplateRecipientsResponseSchema = z.object({
@@ -148,18 +119,7 @@ export const ZUpdateTemplateRecipientResponseSchema = ZRecipientSchema;
 
 export const ZUpdateTemplateRecipientsRequestSchema = z.object({
   templateId: z.number(),
-  recipients: z.array(ZUpdateRecipientSchema).refine(
+  recipients: z.array(ZUpdateRecipientSchema),
-    (recipients) => {
-      const emails = recipients
-        .filter((recipient) => recipient.email !== undefined)
-        .map((recipient) => recipient.email);
-
-      return new Set(emails).size === emails.length;
-    },
-    {
-      message: 'Recipients must have unique emails',
-    },
-  ),
 });
 
 export const ZUpdateTemplateRecipientsResponseSchema = z.object({
@@ -170,8 +130,7 @@ export const ZDeleteTemplateRecipientRequestSchema = z.object({
   recipientId: z.number(),
 });
 
-export const ZSetTemplateRecipientsRequestSchema = z
+export const ZSetTemplateRecipientsRequestSchema = z.object({
-  .object({
   templateId: z.number(),
   recipients: z.array(
     z.object({
@@ -183,16 +142,7 @@ export const ZSetTemplateRecipientsRequestSchema = z
       actionAuth: ZRecipientActionAuthTypesSchema.optional().nullable(),
     }),
   ),
-  })
+});
-  .refine(
-    (schema) => {
-      const emails = schema.recipients.map((recipient) => recipient.email);
-
-      return new Set(emails).size === emails.length;
-    },
-    // Dirty hack to handle errors when .root is populated for an array type
-    { message: 'Recipients must have unique emails', path: ['recipients__root'] },
-  );
 
 export const ZSetTemplateRecipientsResponseSchema = z.object({
   recipients: ZRecipientLiteSchema.array(),

packages/trpc/server/template-router/schema.ts

@@ -51,12 +51,7 @@ export const ZCreateDocumentFromTemplateRequestSchema = z.object({
         name: z.string().optional(),
       }),
     )
-    .describe('The information of the recipients to create the document with.')
+    .describe('The information of the recipients to create the document with.'),
-    .refine((recipients) => {
-      const emails = recipients.map((signer) => signer.email);
-
-      return new Set(emails).size === emails.length;
-    }, 'Recipients must have unique emails'),
   distributeDocument: z
     .boolean()
     .describe('Whether to create the document as pending and distribute it to recipients.')

packages/ui/primitives/document-flow/types.ts

@@ -8,19 +8,14 @@ import { FieldType } from '@documenso/prisma/client';
 export const ZDocumentFlowFormSchema = z.object({
   title: z.string().min(1),
 
-  signers: z
+  signers: z.array(
-    .array(
     z.object({
       formId: z.string().min(1),
       nativeId: z.number().optional(),
       email: z.string().min(1).email(),
       name: z.string(),
     }),
-    )
+  ),
-    .refine((signers) => {
-      const emails = signers.map((signer) => signer.email);
-      return new Set(emails).size === emails.length;
-    }, 'Signers must have unique emails'),
 
   fields: z.array(
     z.object({

packages/ui/primitives/template-flow/add-template-placeholder-recipients.types.ts

@@ -5,8 +5,7 @@ import { DocumentSigningOrder, RecipientRole } from '@documenso/prisma/client';
 
 import { ZMapNegativeOneToUndefinedSchema } from '../document-flow/add-settings.types';
 
-export const ZAddTemplatePlacholderRecipientsFormSchema = z
+export const ZAddTemplatePlacholderRecipientsFormSchema = z.object({
-  .object({
   signers: z.array(
     z.object({
       formId: z.string().min(1),
@@ -15,22 +14,11 @@ export const ZAddTemplatePlacholderRecipientsFormSchema = z
       name: z.string(),
       role: z.nativeEnum(RecipientRole),
       signingOrder: z.number().optional(),
-        actionAuth: ZMapNegativeOneToUndefinedSchema.pipe(
+      actionAuth: ZMapNegativeOneToUndefinedSchema.pipe(ZRecipientActionAuthTypesSchema.optional()),
-          ZRecipientActionAuthTypesSchema.optional(),
-        ),
     }),
   ),
   signingOrder: z.nativeEnum(DocumentSigningOrder),
-  })
+});
-  .refine(
-    (schema) => {
-      const emails = schema.signers.map((signer) => signer.email.toLowerCase());
-
-      return new Set(emails).size === emails.length;
-    },
-    // Dirty hack to handle errors when .root is populated for an array type
-    { message: 'Signers must have unique emails', path: ['signers__root'] },
-  );
 
 export type TAddTemplatePlacholderRecipientsFormSchema = z.infer<
   typeof ZAddTemplatePlacholderRecipientsFormSchema