Ryan/documenso
1
0
Fork 1
mirror of https://github.com/documenso/documenso.git synced 2025-11-19 03:01:59 +10:00
Code Issues Packages Projects Releases Wiki Activity

chore: remove same email check from backend

Browse Source
This commit is contained in:
Catalin Pit
2025-01-27 17:08:55 +02:00
parent 9f9f6701c8
commit 071f5c546d
6 changed files with 48 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
packages/api/v1/schema.ts
View File

@ -259,24 +259,14 @@ export type TCreateDocumentFromTemplateMutationResponseSchema = z.infer<
export const ZGenerateDocumentFromTemplateMutationSchema = z.object({ export const ZGenerateDocumentFromTemplateMutationSchema = z.object({
title: z.string().optional(), title: z.string().optional(),
externalId: z.string().optional(), externalId: z.string().optional(),
recipients: z recipients: z.array(
.array( z.object({
z.object({ id: z.number(),
id: z.number(), email: z.string().email(),
email: z.string().email(), name: z.string().optional(),
name: z.string().optional(), signingOrder: z.number().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 meta: z
.object({ .object({
subject: z.string(), subject: z.string(),

8
packages/trpc/server/document-router/schema.ts
View File

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

84
packages/trpc/server/recipient-router/schema.ts
View File

@ -49,16 +49,7 @@ export const ZCreateDocumentRecipientResponseSchema = ZRecipientLiteSchema;
export const ZCreateDocumentRecipientsRequestSchema = z.object({ export const ZCreateDocumentRecipientsRequestSchema = z.object({
documentId: z.number(), 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({ export const ZCreateDocumentRecipientsResponseSchema = z.object({
@ -74,18 +65,7 @@ export const ZUpdateDocumentRecipientResponseSchema = ZRecipientSchema;
export const ZUpdateDocumentRecipientsRequestSchema = z.object({ export const ZUpdateDocumentRecipientsRequestSchema = z.object({
documentId: z.number(), 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({ export const ZUpdateDocumentRecipientsResponseSchema = z.object({
@ -123,16 +103,7 @@ export const ZCreateTemplateRecipientResponseSchema = ZRecipientLiteSchema;
export const ZCreateTemplateRecipientsRequestSchema = z.object({ export const ZCreateTemplateRecipientsRequestSchema = z.object({
templateId: z.number(), 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({ export const ZCreateTemplateRecipientsResponseSchema = z.object({
@ -148,18 +119,7 @@ export const ZUpdateTemplateRecipientResponseSchema = ZRecipientSchema;
export const ZUpdateTemplateRecipientsRequestSchema = z.object({ export const ZUpdateTemplateRecipientsRequestSchema = z.object({
templateId: z.number(), 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({ export const ZUpdateTemplateRecipientsResponseSchema = z.object({
@ -170,29 +130,19 @@ export const ZDeleteTemplateRecipientRequestSchema = z.object({
recipientId: z.number(), recipientId: z.number(),
}); });
export const ZSetTemplateRecipientsRequestSchema = z export const ZSetTemplateRecipientsRequestSchema = z.object({
.object({ templateId: z.number(),
templateId: z.number(), recipients: z.array(
recipients: z.array( z.object({
z.object({ nativeId: z.number().optional(),
nativeId: z.number().optional(), email: z.string().toLowerCase().email().min(1),
email: z.string().toLowerCase().email().min(1), name: z.string(),
name: z.string(), role: z.nativeEnum(RecipientRole),
role: z.nativeEnum(RecipientRole), signingOrder: z.number().optional(),
signingOrder: z.number().optional(), actionAuth: ZRecipientActionAuthTypesSchema.optional().nullable(),
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({ export const ZSetTemplateRecipientsResponseSchema = z.object({
recipients: ZRecipientLiteSchema.array(), recipients: ZRecipientLiteSchema.array(),

7
packages/trpc/server/template-router/schema.ts
View File

@ -51,12 +51,7 @@ export const ZCreateDocumentFromTemplateRequestSchema = z.object({
name: z.string().optional(), 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 distributeDocument: z
.boolean() .boolean()
.describe('Whether to create the document as pending and distribute it to recipients.') .describe('Whether to create the document as pending and distribute it to recipients.')

21
packages/ui/primitives/document-flow/types.ts
View File

@ -8,19 +8,14 @@ import { FieldType } from '@documenso/prisma/client';
export const ZDocumentFlowFormSchema = z.object({ export const ZDocumentFlowFormSchema = z.object({
title: z.string().min(1), title: z.string().min(1),
signers: z signers: z.array(
.array( z.object({
z.object({ formId: z.string().min(1),
formId: z.string().min(1), nativeId: z.number().optional(),
nativeId: z.number().optional(), email: z.string().min(1).email(),
email: z.string().min(1).email(), name: z.string(),
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( fields: z.array(
z.object({ z.object({

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

@ -5,32 +5,20 @@ import { DocumentSigningOrder, RecipientRole } from '@documenso/prisma/client';
import { ZMapNegativeOneToUndefinedSchema } from '../document-flow/add-settings.types'; import { ZMapNegativeOneToUndefinedSchema } from '../document-flow/add-settings.types';
export const ZAddTemplatePlacholderRecipientsFormSchema = z export const ZAddTemplatePlacholderRecipientsFormSchema = z.object({
.object({ signers: z.array(
signers: z.array( z.object({
z.object({ formId: z.string().min(1),
formId: z.string().min(1), nativeId: z.number().optional(),
nativeId: z.number().optional(), email: z.string().min(1).email(),
email: z.string().min(1).email(), name: z.string(),
name: z.string(), role: z.nativeEnum(RecipientRole),
role: z.nativeEnum(RecipientRole), signingOrder: z.number().optional(),
signingOrder: z.number().optional(), actionAuth: ZMapNegativeOneToUndefinedSchema.pipe(ZRecipientActionAuthTypesSchema.optional()),
actionAuth: ZMapNegativeOneToUndefinedSchema.pipe( }),
ZRecipientActionAuthTypesSchema.optional(), ),
), signingOrder: z.nativeEnum(DocumentSigningOrder),
}), });
),
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< export type TAddTemplatePlacholderRecipientsFormSchema = z.infer<
typeof ZAddTemplatePlacholderRecipientsFormSchema typeof ZAddTemplatePlacholderRecipientsFormSchema