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

fix: move open meta around

Browse Source
This commit is contained in:
David Nguyen
2025-11-06 16:40:55 +11:00
parent 1592fbd369
commit 4e38d861f6
58 changed files with 370 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
apps/remix/app/components/dialogs/document-duplicate-dialog.tsx
View File

@ -49,20 +49,20 @@ export const DocumentDuplicateDialog = ({
},
);
const envelopeItems = envelopeItemsPayload?.envelopeItems || [];
const envelopeItems = envelopeItemsPayload?.data || [];
const documentsPath = formatDocumentsPath(team.url);
const { mutateAsync: duplicateEnvelope, isPending: isDuplicating } =
trpcReact.envelope.duplicate.useMutation({
onSuccess: async ({ duplicatedEnvelopeId }) => {
onSuccess: async ({ id }) => {
toast({
title: _(msg`Document Duplicated`),
description: _(msg`Your document has been successfully duplicated.`),
duration: 5000,
});
await navigate(`${documentsPath}/${duplicatedEnvelopeId}/edit`);
await navigate(`${documentsPath}/${id}/edit`);
onOpenChange(false);
},
});

4
apps/remix/app/components/dialogs/envelope-download-dialog.tsx
View File

@ -61,12 +61,12 @@ export const EnvelopeDownloadDialog = ({
access: token ? { type: 'recipient', token } : { type: 'user' },
},
{
initialData: initialEnvelopeItems ? { envelopeItems: initialEnvelopeItems } : undefined,
initialData: initialEnvelopeItems ? { data: initialEnvelopeItems } : undefined,
enabled: open,
},
);
const envelopeItems = envelopeItemsPayload?.envelopeItems || [];
const envelopeItems = envelopeItemsPayload?.data || [];
const onDownload = async (
envelopeItem: EnvelopeItemToDownload,

4
apps/remix/app/components/dialogs/envelope-duplicate-dialog.tsx
View File

@ -43,7 +43,7 @@ export const EnvelopeDuplicateDialog = ({
const { mutateAsync: duplicateEnvelope, isPending: isDuplicating } =
trpc.envelope.duplicate.useMutation({
onSuccess: async ({ duplicatedEnvelopeId }) => {
onSuccess: async ({ id }) => {
toast({
title: t`Envelope Duplicated`,
description: t`Your envelope has been successfully duplicated.`,
@ -55,7 +55,7 @@ export const EnvelopeDuplicateDialog = ({
? formatDocumentsPath(team.url)
: formatTemplatesPath(team.url);
await navigate(`${path}/${duplicatedEnvelopeId}/edit`);
await navigate(`${path}/${id}/edit`);
setOpen(false);
},
});

2
apps/remix/app/components/dialogs/template-use-dialog.tsx
View File

@ -143,7 +143,7 @@ export function TemplateUseDialog({
},
);
const envelopeItems = response?.envelopeItems ?? [];
const envelopeItems = response?.data ?? [];
const { mutateAsync: createDocumentFromTemplate } =
trpc.template.createDocumentFromTemplate.useMutation();

12
apps/remix/app/components/general/envelope-editor/envelope-editor-upload-page.tsx
View File

@ -67,8 +67,8 @@ export const EnvelopeEditorUploadPage = () => {
const { mutateAsync: createEnvelopeItems, isPending: isCreatingEnvelopeItems } =
trpc.envelope.item.createMany.useMutation({
onSuccess: (data) => {
const createdEnvelopes = data.createdEnvelopeItems.filter(
onSuccess: ({ data }) => {
const createdEnvelopes = data.filter(
(item) => !envelope.envelopeItems.find((envelopeItem) => envelopeItem.id === item.id),
);
@ -79,10 +79,10 @@ export const EnvelopeEditorUploadPage = () => {
});
const { mutateAsync: updateEnvelopeItems } = trpc.envelope.item.updateMany.useMutation({
onSuccess: (data) => {
onSuccess: ({ data }) => {
setLocalEnvelope({
envelopeItems: envelope.envelopeItems.map((originalItem) => {
const updatedItem = data.updatedEnvelopeItems.find((item) => item.id === originalItem.id);
const updatedItem = data.find((item) => item.id === originalItem.id);
if (updatedItem) {
return {
@ -126,7 +126,7 @@ export const EnvelopeEditorUploadPage = () => {
formData.append('files', file);
}
const { createdEnvelopeItems } = await createEnvelopeItems(formData).catch((error) => {
const { data } = await createEnvelopeItems(formData).catch((error) => {
console.error(error);
// Set error state on files in batch upload.
@ -148,7 +148,7 @@ export const EnvelopeEditorUploadPage = () => {
);
return filteredFiles.concat(
createdEnvelopeItems.map((item) => ({
data.map((item) => ({
id: item.id,
envelopeItemId: item.id,
title: item.title,

4
packages/lib/client-only/providers/envelope-editor-provider.tsx
View File

@ -150,7 +150,7 @@ export const EnvelopeEditorProvider = ({
});
const envelopeRecipientSetMutationQuery = trpc.envelope.recipient.set.useMutation({
onSuccess: ({ recipients }) => {
onSuccess: ({ data: recipients }) => {
setEnvelope((prev) => ({
...prev,
recipients,
@ -196,7 +196,7 @@ export const EnvelopeEditorProvider = ({
});
// Insert the IDs into the local fields.
envelopeFields.fields.forEach((field) => {
envelopeFields.data.forEach((field) => {
const localField = localFields.find((localField) => localField.formId === field.formId);
if (localField && !localField.id) {

11
packages/trpc/server/envelope-router/attachment/create-attachment.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZCreateAttachmentRequestSchema,
ZCreateAttachmentResponseSchema,
createAttachmentMeta,
} from './create-attachment.types';
export const createAttachmentRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/attachment/create',
summary: 'Create attachment',
description: 'Create a new attachment for an envelope',
tags: ['Envelope Attachments'],
},
})
.meta(createAttachmentMeta)
.input(ZCreateAttachmentRequestSchema)
.output(ZCreateAttachmentResponseSchema)
.mutation(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/attachment/create-attachment.types.ts
View File

@ -1,5 +1,17 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../../trpc';
export const createAttachmentMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/attachment/create',
summary: 'Create attachment',
description: 'Create a new attachment for an envelope',
tags: ['Envelope Attachments'],
},
};
export const ZCreateAttachmentRequestSchema = z.object({
envelopeId: z.string(),
data: z.object({

11
packages/trpc/server/envelope-router/attachment/delete-attachment.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZDeleteAttachmentRequestSchema,
ZDeleteAttachmentResponseSchema,
deleteAttachmentMeta,
} from './delete-attachment.types';
export const deleteAttachmentRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/attachment/delete',
summary: 'Delete attachment',
description: 'Delete an attachment from an envelope',
tags: ['Envelope Attachments'],
},
})
.meta(deleteAttachmentMeta)
.input(ZDeleteAttachmentRequestSchema)
.output(ZDeleteAttachmentResponseSchema)
.mutation(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/attachment/delete-attachment.types.ts
View File

@ -1,5 +1,17 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../../trpc';
export const deleteAttachmentMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/attachment/delete',
summary: 'Delete attachment',
description: 'Delete an attachment from an envelope',
tags: ['Envelope Attachments'],
},
};
export const ZDeleteAttachmentRequestSchema = z.object({
id: z.string(),
});

11
packages/trpc/server/envelope-router/attachment/find-attachments.ts
View File

@ -6,18 +6,11 @@ import { maybeAuthenticatedProcedure } from '../../trpc';
import {
ZFindAttachmentsRequestSchema,
ZFindAttachmentsResponseSchema,
findAttachmentsMeta,
} from './find-attachments.types';
export const findAttachmentsRoute = maybeAuthenticatedProcedure
.meta({
openapi: {
method: 'GET',
path: '/envelope/attachment',
summary: 'Find attachments',
description: 'Find all attachments for an envelope',
tags: ['Envelope Attachments'],
},
})
.meta(findAttachmentsMeta)
.input(ZFindAttachmentsRequestSchema)
.output(ZFindAttachmentsResponseSchema)
.query(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/attachment/find-attachments.types.ts
View File

@ -2,6 +2,18 @@ import { z } from 'zod';
import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
import type { TrpcRouteMeta } from '../../trpc';
export const findAttachmentsMeta: TrpcRouteMeta = {
openapi: {
method: 'GET',
path: '/envelope/attachment',
summary: 'Find attachments',
description: 'Find all attachments for an envelope',
tags: ['Envelope Attachments'],
},
};
export const ZFindAttachmentsRequestSchema = z.object({
envelopeId: z.string(),
token: z.string().optional(),

11
packages/trpc/server/envelope-router/attachment/update-attachment.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZUpdateAttachmentRequestSchema,
ZUpdateAttachmentResponseSchema,
updateAttachmentMeta,
} from './update-attachment.types';
export const updateAttachmentRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/attachment/update',
summary: 'Update attachment',
description: 'Update an existing attachment',
tags: ['Envelope Attachments'],
},
})
.meta(updateAttachmentMeta)
.input(ZUpdateAttachmentRequestSchema)
.output(ZUpdateAttachmentResponseSchema)
.mutation(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/attachment/update-attachment.types.ts
View File

@ -1,5 +1,17 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../../trpc';
export const updateAttachmentMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/attachment/update',
summary: 'Update attachment',
description: 'Update an existing attachment',
tags: ['Envelope Attachments'],
},
};
export const ZUpdateAttachmentRequestSchema = z.object({
id: z.string(),
data: z.object({

13
packages/trpc/server/envelope-router/create-envelope-items.ts
View File

@ -11,18 +11,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZCreateEnvelopeItemsRequestSchema,
ZCreateEnvelopeItemsResponseSchema,
createEnvelopeItemsMeta,
} from './create-envelope-items.types';
export const createEnvelopeItemsRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/item/create-many',
summary: 'Create envelope items',
description: 'Create multiple envelope items for an envelope',
tags: ['Envelope Items'],
},
})
.meta(createEnvelopeItemsMeta)
.input(ZCreateEnvelopeItemsRequestSchema)
.output(ZCreateEnvelopeItemsResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -142,6 +135,6 @@ export const createEnvelopeItemsRoute = authenticatedProcedure
});
return {
createdEnvelopeItems: result,
data: result,
};
});

13
packages/trpc/server/envelope-router/create-envelope-items.types.ts
View File

@ -4,6 +4,17 @@ import { zfd } from 'zod-form-data';
import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
import { zodFormData } from '../../utils/zod-form-data';
import type { TrpcRouteMeta } from '../trpc';
export const createEnvelopeItemsMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/item/create-many',
summary: 'Create envelope items',
description: 'Create multiple envelope items for an envelope',
tags: ['Envelope Items'],
},
};
export const ZCreateEnvelopeItemsPayloadSchema = z.object({
envelopeId: z.string(),
@ -16,7 +27,7 @@ export const ZCreateEnvelopeItemsRequestSchema = zodFormData({
});
export const ZCreateEnvelopeItemsResponseSchema = z.object({
createdEnvelopeItems: EnvelopeItemSchema.pick({
data: EnvelopeItemSchema.pick({
id: true,
title: true,
envelopeId: true,

10
packages/trpc/server/envelope-router/create-envelope.ts
View File

@ -7,17 +7,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZCreateEnvelopeRequestSchema,
ZCreateEnvelopeResponseSchema,
createEnvelopeMeta,
} from './create-envelope.types';
export const createEnvelopeRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/create',
summary: 'Create envelope',
tags: ['Envelope'],
},
})
.meta(createEnvelopeMeta)
.input(ZCreateEnvelopeRequestSchema)
.output(ZCreateEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {

3
packages/trpc/server/envelope-router/create-envelope.types.ts
View File

@ -27,14 +27,13 @@ import {
import { ZCreateRecipientSchema } from '../recipient-router/schema';
import type { TrpcRouteMeta } from '../trpc';
// Currently not in use until we allow passthrough documents on create.
export const createEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/create',
contentTypes: ['multipart/form-data'],
summary: 'Create envelope',
description: 'Create a envelope using form data.',
description: 'Create an envelope using form data.',
tags: ['Envelope'],
},
};

11
packages/trpc/server/envelope-router/delete-envelope-item.ts
View File

@ -9,18 +9,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZDeleteEnvelopeItemRequestSchema,
ZDeleteEnvelopeItemResponseSchema,
deleteEnvelopeItemMeta,
} from './delete-envelope-item.types';
export const deleteEnvelopeItemRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/item/delete',
summary: 'Delete envelope item',
description: 'Delete an envelope item from an envelope',
tags: ['Envelope Items'],
},
})
.meta(deleteEnvelopeItemMeta)
.input(ZDeleteEnvelopeItemRequestSchema)
.output(ZDeleteEnvelopeItemResponseSchema)
.mutation(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/delete-envelope-item.types.ts
View File

@ -1,5 +1,17 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../trpc';
export const deleteEnvelopeItemMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/item/delete',
summary: 'Delete envelope item',
description: 'Delete an envelope item from an envelope',
tags: ['Envelope Items'],
},
};
export const ZDeleteEnvelopeItemRequestSchema = z.object({
envelopeId: z.string(),
envelopeItemId: z.string(),

10
packages/trpc/server/envelope-router/delete-envelope.ts
View File

@ -10,17 +10,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZDeleteEnvelopeRequestSchema,
ZDeleteEnvelopeResponseSchema,
deleteEnvelopeMeta,
} from './delete-envelope.types';
export const deleteEnvelopeRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/delete',
summary: 'Delete envelope',
tags: ['Envelope'],
},
})
.meta(deleteEnvelopeMeta)
.input(ZDeleteEnvelopeRequestSchema)
.output(ZDeleteEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {

11
packages/trpc/server/envelope-router/delete-envelope.types.ts
View File

@ -1,5 +1,16 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../trpc';
export const deleteEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/delete',
summary: 'Delete envelope',
tags: ['Envelope'],
},
};
export const ZDeleteEnvelopeRequestSchema = z.object({
envelopeId: z.string(),
});

11
packages/trpc/server/envelope-router/distribute-envelope.ts
View File

@ -5,18 +5,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZDistributeEnvelopeRequestSchema,
ZDistributeEnvelopeResponseSchema,
distributeEnvelopeMeta,
} from './distribute-envelope.types';
export const distributeEnvelopeRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/distribute',
summary: 'Distribute envelope',
description: 'Send the envelope to recipients based on your distribution method',
tags: ['Envelope'],
},
})
.meta(distributeEnvelopeMeta)
.input(ZDistributeEnvelopeRequestSchema)
.output(ZDistributeEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/distribute-envelope.types.ts
View File

@ -2,6 +2,18 @@ import { z } from 'zod';
import { ZDocumentMetaUpdateSchema } from '@documenso/lib/types/document-meta';
import type { TrpcRouteMeta } from '../trpc';
export const distributeEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/distribute',
summary: 'Distribute envelope',
description: 'Send the envelope to recipients based on your distribution method',
tags: ['Envelope'],
},
};
export const ZDistributeEnvelopeRequestSchema = z.object({
envelopeId: z.string().describe('The ID of the envelope to send.'),
meta: ZDocumentMetaUpdateSchema.pick({

13
packages/trpc/server/envelope-router/duplicate-envelope.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZDuplicateEnvelopeRequestSchema,
ZDuplicateEnvelopeResponseSchema,
duplicateEnvelopeMeta,
} from './duplicate-envelope.types';
export const duplicateEnvelopeRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/duplicate',
summary: 'Duplicate envelope',
description: 'Duplicate an envelope with all its settings',
tags: ['Envelope'],
},
})
.meta(duplicateEnvelopeMeta)
.input(ZDuplicateEnvelopeRequestSchema)
.output(ZDuplicateEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -38,6 +31,6 @@ export const duplicateEnvelopeRoute = authenticatedProcedure
});
return {
duplicatedEnvelopeId: duplicatedEnvelope.id,
id: duplicatedEnvelope.id,
};
});

14
packages/trpc/server/envelope-router/duplicate-envelope.types.ts
View File

@ -1,11 +1,23 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../trpc';
export const duplicateEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/duplicate',
summary: 'Duplicate envelope',
description: 'Duplicate an envelope with all its settings',
tags: ['Envelope'],
},
};
export const ZDuplicateEnvelopeRequestSchema = z.object({
envelopeId: z.string(),
});
export const ZDuplicateEnvelopeResponseSchema = z.object({
duplicatedEnvelopeId: z.string(),
id: z.string().describe('The ID of the newly created envelope.'),
});
export type TDuplicateEnvelopeRequest = z.infer<typeof ZDuplicateEnvelopeRequestSchema>;

17
packages/trpc/server/envelope-router/envelope-fields/create-envelope-fields.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZCreateEnvelopeFieldsRequestSchema,
ZCreateEnvelopeFieldsResponseSchema,
createEnvelopeFieldsMeta,
} from './create-envelope-fields.types';
export const createEnvelopeFieldsRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/field/create-many',
summary: 'Create envelope fields',
description: 'Create multiple fields for an envelope',
tags: ['Envelope Fields'],
},
})
.meta(createEnvelopeFieldsMeta)
.input(ZCreateEnvelopeFieldsRequestSchema)
.output(ZCreateEnvelopeFieldsResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -28,7 +21,7 @@ export const createEnvelopeFieldsRoute = authenticatedProcedure
},
});
return await createEnvelopeFields({
const { fields: data } = await createEnvelopeFields({
userId: user.id,
teamId,
id: {
@ -38,4 +31,8 @@ export const createEnvelopeFieldsRoute = authenticatedProcedure
fields,
requestMetadata: metadata,
});
return {
data,
};
});

15
packages/trpc/server/envelope-router/envelope-fields/create-envelope-fields.types.ts
View File

@ -10,6 +10,19 @@ import {
} from '@documenso/lib/types/field';
import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
import type { TrpcRouteMeta } from '../../trpc';
export const createEnvelopeFieldsMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/field/create-many',
contentTypes: ['multipart/form-data'],
summary: 'Create envelope fields',
description: 'Create multiple fields for an envelope',
tags: ['Envelope Fields'],
},
};
const ZCreateFieldSchema = ZFieldAndMetaSchema.and(
z.object({
recipientId: z.number().describe('The ID of the recipient to create the field for'),
@ -33,7 +46,7 @@ export const ZCreateEnvelopeFieldsRequestSchema = z.object({
});
export const ZCreateEnvelopeFieldsResponseSchema = z.object({
fields: z.array(ZFieldSchema),
data: z.array(ZFieldSchema),
});
export type TCreateEnvelopeFieldsRequest = z.infer<typeof ZCreateEnvelopeFieldsRequestSchema>;

11
packages/trpc/server/envelope-router/envelope-fields/delete-envelope-field.ts
View File

@ -11,18 +11,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZDeleteEnvelopeFieldRequestSchema,
ZDeleteEnvelopeFieldResponseSchema,
deleteEnvelopeFieldMeta,
} from './delete-envelope-field.types';
export const deleteEnvelopeFieldRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/field/delete',
summary: 'Delete envelope field',
description: 'Delete an envelope field',
tags: ['Envelope Fields'],
},
})
.meta(deleteEnvelopeFieldMeta)
.input(ZDeleteEnvelopeFieldRequestSchema)
.output(ZDeleteEnvelopeFieldResponseSchema)
.mutation(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/envelope-fields/delete-envelope-field.types.ts
View File

@ -1,5 +1,17 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../../trpc';
export const deleteEnvelopeFieldMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/field/delete',
summary: 'Delete envelope field',
description: 'Delete an envelope field',
tags: ['Envelope Fields'],
},
};
export const ZDeleteEnvelopeFieldRequestSchema = z.object({
fieldId: z.number(),
});

11
packages/trpc/server/envelope-router/envelope-fields/get-envelope-field.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZGetEnvelopeFieldRequestSchema,
ZGetEnvelopeFieldResponseSchema,
getEnvelopeFieldMeta,
} from './get-envelope-field.types';
export const getEnvelopeFieldRoute = authenticatedProcedure
.meta({
openapi: {
method: 'GET',
path: '/envelope/field/{fieldId}',
summary: 'Get envelope field',
description: 'Returns an envelope field given an ID',
tags: ['Envelope Fields'],
},
})
.meta(getEnvelopeFieldMeta)
.input(ZGetEnvelopeFieldRequestSchema)
.output(ZGetEnvelopeFieldResponseSchema)
.query(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/envelope-fields/get-envelope-field.types.ts
View File

@ -2,6 +2,18 @@ import { z } from 'zod';
import { ZEnvelopeFieldSchema } from '@documenso/lib/types/field';
import type { TrpcRouteMeta } from '../../trpc';
export const getEnvelopeFieldMeta: TrpcRouteMeta = {
openapi: {
method: 'GET',
path: '/envelope/field/{fieldId}',
summary: 'Get envelope field',
description: 'Returns an envelope field given an ID',
tags: ['Envelope Fields'],
},
};
export const ZGetEnvelopeFieldRequestSchema = z.object({
fieldId: z.number(),
});

17
packages/trpc/server/envelope-router/envelope-fields/update-envelope-fields.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZUpdateEnvelopeFieldsRequestSchema,
ZUpdateEnvelopeFieldsResponseSchema,
updateEnvelopeFieldsMeta,
} from './update-envelope-fields.types';
export const updateEnvelopeFieldsRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/field/update-many',
summary: 'Update envelope fields',
description: 'Update multiple envelope fields for an envelope',
tags: ['Envelope Fields'],
},
})
.meta(updateEnvelopeFieldsMeta)
.input(ZUpdateEnvelopeFieldsRequestSchema)
.output(ZUpdateEnvelopeFieldsResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -28,7 +21,7 @@ export const updateEnvelopeFieldsRoute = authenticatedProcedure
},
});
return await updateEnvelopeFields({
const { fields: data } = await updateEnvelopeFields({
userId: user.id,
teamId,
id: {
@ -39,4 +32,8 @@ export const updateEnvelopeFieldsRoute = authenticatedProcedure
fields,
requestMetadata: ctx.metadata,
});
return {
data,
};
});

14
packages/trpc/server/envelope-router/envelope-fields/update-envelope-fields.types.ts
View File

@ -10,6 +10,18 @@ import {
} from '@documenso/lib/types/field';
import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
import type { TrpcRouteMeta } from '../../trpc';
export const updateEnvelopeFieldsMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/field/update-many',
summary: 'Update envelope fields',
description: 'Update multiple envelope fields for an envelope',
tags: ['Envelope Fields'],
},
};
const ZUpdateFieldSchema = ZFieldAndMetaSchema.and(
z.object({
id: z.number().describe('The ID of the field to update.'),
@ -33,7 +45,7 @@ export const ZUpdateEnvelopeFieldsRequestSchema = z.object({
});
export const ZUpdateEnvelopeFieldsResponseSchema = z.object({
fields: z.array(ZFieldSchema),
data: z.array(ZFieldSchema),
});
export type TUpdateEnvelopeFieldsRequest = z.infer<typeof ZUpdateEnvelopeFieldsRequestSchema>;

17
packages/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZCreateEnvelopeRecipientsRequestSchema,
ZCreateEnvelopeRecipientsResponseSchema,
createEnvelopeRecipientsMeta,
} from './create-envelope-recipients.types';
export const createEnvelopeRecipientsRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/recipient/create-many',
summary: 'Create envelope recipients',
description: 'Create multiple recipients for an envelope',
tags: ['Envelope Recipients'],
},
})
.meta(createEnvelopeRecipientsMeta)
.input(ZCreateEnvelopeRecipientsRequestSchema)
.output(ZCreateEnvelopeRecipientsResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -28,7 +21,7 @@ export const createEnvelopeRecipientsRoute = authenticatedProcedure
},
});
return await createEnvelopeRecipients({
const { recipients: data } = await createEnvelopeRecipients({
userId: user.id,
teamId,
id: {
@ -38,4 +31,8 @@ export const createEnvelopeRecipientsRoute = authenticatedProcedure
recipients,
requestMetadata: metadata,
});
return {
data,
};
});

13
packages/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.types.ts
View File

@ -3,6 +3,17 @@ import { z } from 'zod';
import { ZEnvelopeRecipientLiteSchema } from '@documenso/lib/types/recipient';
import { ZCreateRecipientSchema } from '../../recipient-router/schema';
import type { TrpcRouteMeta } from '../../trpc';
export const createEnvelopeRecipientsMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/recipient/create-many',
summary: 'Create envelope recipients',
description: 'Create multiple recipients for an envelope',
tags: ['Envelope Recipients'],
},
};
export const ZCreateEnvelopeRecipientsRequestSchema = z.object({
envelopeId: z.string(),
@ -10,7 +21,7 @@ export const ZCreateEnvelopeRecipientsRequestSchema = z.object({
});
export const ZCreateEnvelopeRecipientsResponseSchema = z.object({
recipients: ZEnvelopeRecipientLiteSchema.array(),
data: ZEnvelopeRecipientLiteSchema.array(),
});
export type TCreateEnvelopeRecipientsRequest = z.infer<

11
packages/trpc/server/envelope-router/envelope-recipients/delete-envelope-recipient.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZDeleteEnvelopeRecipientRequestSchema,
ZDeleteEnvelopeRecipientResponseSchema,
deleteEnvelopeRecipientMeta,
} from './delete-envelope-recipient.types';
export const deleteEnvelopeRecipientRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/recipient/delete',
summary: 'Delete envelope recipient',
description: 'Delete an envelope recipient',
tags: ['Envelope Recipients'],
},
})
.meta(deleteEnvelopeRecipientMeta)
.input(ZDeleteEnvelopeRecipientRequestSchema)
.output(ZDeleteEnvelopeRecipientResponseSchema)
.mutation(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/envelope-recipients/delete-envelope-recipient.types.ts
View File

@ -1,5 +1,17 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../../trpc';
export const deleteEnvelopeRecipientMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/recipient/delete',
summary: 'Delete envelope recipient',
description: 'Delete an envelope recipient',
tags: ['Envelope Recipients'],
},
};
export const ZDeleteEnvelopeRecipientRequestSchema = z.object({
recipientId: z.number(),
});

11
packages/trpc/server/envelope-router/envelope-recipients/get-envelope-recipient.ts
View File

@ -6,18 +6,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZGetEnvelopeRecipientRequestSchema,
ZGetEnvelopeRecipientResponseSchema,
getEnvelopeRecipientMeta,
} from './get-envelope-recipient.types';
export const getEnvelopeRecipientRoute = authenticatedProcedure
.meta({
openapi: {
method: 'GET',
path: '/envelope/recipient/{recipientId}',
summary: 'Get envelope recipient',
description: 'Returns an envelope recipient given an ID',
tags: ['Envelope Recipients'],
},
})
.meta(getEnvelopeRecipientMeta)
.input(ZGetEnvelopeRecipientRequestSchema)
.output(ZGetEnvelopeRecipientResponseSchema)
.query(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/envelope-recipients/get-envelope-recipient.types.ts
View File

@ -2,6 +2,18 @@ import { z } from 'zod';
import { ZEnvelopeRecipientSchema } from '@documenso/lib/types/recipient';
import type { TrpcRouteMeta } from '../../trpc';
export const getEnvelopeRecipientMeta: TrpcRouteMeta = {
openapi: {
method: 'GET',
path: '/envelope/recipient/{recipientId}',
summary: 'Get envelope recipient',
description: 'Returns an envelope recipient given an ID',
tags: ['Envelope Recipients'],
},
};
export const ZGetEnvelopeRecipientRequestSchema = z.object({
recipientId: z.number(),
});

17
packages/trpc/server/envelope-router/envelope-recipients/update-envelope-recipients.ts
View File

@ -4,18 +4,11 @@ import { authenticatedProcedure } from '../../trpc';
import {
ZUpdateEnvelopeRecipientsRequestSchema,
ZUpdateEnvelopeRecipientsResponseSchema,
updateEnvelopeRecipientsMeta,
} from './update-envelope-recipients.types';
export const updateEnvelopeRecipientsRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/recipient/update-many',
summary: 'Update envelope recipients',
description: 'Update multiple recipients for an envelope',
tags: ['Envelope Recipients'],
},
})
.meta(updateEnvelopeRecipientsMeta)
.input(ZUpdateEnvelopeRecipientsRequestSchema)
.output(ZUpdateEnvelopeRecipientsResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -28,7 +21,7 @@ export const updateEnvelopeRecipientsRoute = authenticatedProcedure
},
});
return await updateEnvelopeRecipients({
const { recipients: data } = await updateEnvelopeRecipients({
userId: user.id,
teamId,
id: {
@ -38,4 +31,8 @@ export const updateEnvelopeRecipientsRoute = authenticatedProcedure
recipients,
requestMetadata: ctx.metadata,
});
return {
data,
};
});

13
packages/trpc/server/envelope-router/envelope-recipients/update-envelope-recipients.types.ts
View File

@ -3,6 +3,17 @@ import { z } from 'zod';
import { ZRecipientLiteSchema } from '@documenso/lib/types/recipient';
import { ZUpdateRecipientSchema } from '../../recipient-router/schema';
import type { TrpcRouteMeta } from '../../trpc';
export const updateEnvelopeRecipientsMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/recipient/update-many',
summary: 'Update envelope recipients',
description: 'Update multiple recipients for an envelope',
tags: ['Envelope Recipients'],
},
};
export const ZUpdateEnvelopeRecipientsRequestSchema = z.object({
envelopeId: z.string(),
@ -10,7 +21,7 @@ export const ZUpdateEnvelopeRecipientsRequestSchema = z.object({
});
export const ZUpdateEnvelopeRecipientsResponseSchema = z.object({
recipients: ZRecipientLiteSchema.array(),
data: ZRecipientLiteSchema.array(),
});
export type TUpdateEnvelopeRecipientsRequest = z.infer<

19
packages/trpc/server/envelope-router/get-envelope-items-by-token.ts
View File

@ -34,10 +34,25 @@ export const getEnvelopeItemsByTokenRoute = maybeAuthenticatedProcedure
});
}
return await handleGetEnvelopeItemsByUser({ envelopeId, userId: user.id, teamId });
const { envelopeItems: data } = await handleGetEnvelopeItemsByUser({
envelopeId,
userId: user.id,
teamId,
});
return {
data,
};
}
return await handleGetEnvelopeItemsByToken({ envelopeId, token: access.token });
const { envelopeItems: data } = await handleGetEnvelopeItemsByToken({
envelopeId,
token: access.token,
});
return {
data,
};
});
const handleGetEnvelopeItemsByToken = async ({

2
packages/trpc/server/envelope-router/get-envelope-items-by-token.types.ts
View File

@ -16,7 +16,7 @@ export const ZGetEnvelopeItemsByTokenRequestSchema = z.object({
});
export const ZGetEnvelopeItemsByTokenResponseSchema = z.object({
envelopeItems: EnvelopeItemSchema.pick({
data: EnvelopeItemSchema.pick({
id: true,
envelopeId: true,
title: true,

2
packages/trpc/server/envelope-router/get-envelope-items.ts
View File

@ -50,6 +50,6 @@ export const getEnvelopeItemsRoute = authenticatedProcedure
}
return {
envelopeItems: envelope.envelopeItems,
data: envelope.envelopeItems,
};
});

2
packages/trpc/server/envelope-router/get-envelope-items.types.ts
View File

@ -8,7 +8,7 @@ export const ZGetEnvelopeItemsRequestSchema = z.object({
});
export const ZGetEnvelopeItemsResponseSchema = z.object({
envelopeItems: EnvelopeItemSchema.pick({
data: EnvelopeItemSchema.pick({
id: true,
title: true,
order: true,

16
packages/trpc/server/envelope-router/get-envelope.ts
View File

@ -1,18 +1,14 @@
import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
import { authenticatedProcedure } from '../trpc';
import { ZGetEnvelopeRequestSchema, ZGetEnvelopeResponseSchema } from './get-envelope.types';
import {
ZGetEnvelopeRequestSchema,
ZGetEnvelopeResponseSchema,
getEnvelopeMeta,
} from './get-envelope.types';
export const getEnvelopeRoute = authenticatedProcedure
.meta({
openapi: {
method: 'GET',
path: '/envelope/{envelopeId}',
summary: 'Get envelope',
description: 'Returns an envelope given an ID',
tags: ['Envelope'],
},
})
.meta(getEnvelopeMeta)
.input(ZGetEnvelopeRequestSchema)
.output(ZGetEnvelopeResponseSchema)
.query(async ({ input, ctx }) => {

12
packages/trpc/server/envelope-router/get-envelope.types.ts
View File

@ -2,6 +2,18 @@ import { z } from 'zod';
import { ZEnvelopeSchema } from '@documenso/lib/types/envelope';
import type { TrpcRouteMeta } from '../trpc';
export const getEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'GET',
path: '/envelope/{envelopeId}',
summary: 'Get envelope',
description: 'Returns an envelope given an ID',
tags: ['Envelope'],
},
};
export const ZGetEnvelopeRequestSchema = z.object({
envelopeId: z.string(),
});

12
packages/trpc/server/envelope-router/redistribute-envelope.ts
View File

@ -4,19 +4,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZRedistributeEnvelopeRequestSchema,
ZRedistributeEnvelopeResponseSchema,
redistributeEnvelopeMeta,
} from './redistribute-envelope.types';
export const redistributeEnvelopeRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/redistribute',
summary: 'Redistribute envelope',
description:
'Redistribute the envelope to the provided recipients who have not actioned the envelope. Will use the distribution method set in the envelope',
tags: ['Envelope'],
},
})
.meta(redistributeEnvelopeMeta)
.input(ZRedistributeEnvelopeRequestSchema)
.output(ZRedistributeEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {

13
packages/trpc/server/envelope-router/redistribute-envelope.types.ts
View File

@ -1,5 +1,18 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../trpc';
export const redistributeEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/redistribute',
summary: 'Redistribute envelope',
description:
'Redistribute the envelope to the provided recipients who have not actioned the envelope. Will use the distribution method set in the envelope',
tags: ['Envelope'],
},
};
export const ZRedistributeEnvelopeRequestSchema = z.object({
envelopeId: z.string(),
recipients: z

2
packages/trpc/server/envelope-router/set-envelope-fields.ts
View File

@ -65,7 +65,7 @@ export const setEnvelopeFieldsRoute = authenticatedProcedure
.exhaustive();
return {
fields: result.fields.map((field) => ({
data: result.fields.map((field) => ({
id: field.id,
formId: field.formId,
})),

2
packages/trpc/server/envelope-router/set-envelope-fields.types.ts
View File

@ -37,7 +37,7 @@ export const ZSetEnvelopeFieldsRequestSchema = z.object({
});
export const ZSetEnvelopeFieldsResponseSchema = z.object({
fields: z
data: z
.object({
id: z.number(),
formId: z.string().optional(),

6
packages/trpc/server/envelope-router/set-envelope-recipients.ts
View File

@ -23,7 +23,7 @@ export const setEnvelopeRecipientsRoute = authenticatedProcedure
},
});
return await match(envelopeType)
const { recipients: data } = await match(envelopeType)
.with(EnvelopeType.DOCUMENT, async () =>
setDocumentRecipients({
userId: ctx.user.id,
@ -48,4 +48,8 @@ export const setEnvelopeRecipientsRoute = authenticatedProcedure
}),
)
.exhaustive();
return {
data,
};
});

2
packages/trpc/server/envelope-router/set-envelope-recipients.types.ts
View File

@ -20,7 +20,7 @@ export const ZSetEnvelopeRecipientsRequestSchema = z.object({
});
export const ZSetEnvelopeRecipientsResponseSchema = z.object({
recipients: ZRecipientLiteSchema.omit({
data: ZRecipientLiteSchema.omit({
documentId: true,
templateId: true,
}).array(),

13
packages/trpc/server/envelope-router/update-envelope-items.ts
View File

@ -7,18 +7,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZUpdateEnvelopeItemsRequestSchema,
ZUpdateEnvelopeItemsResponseSchema,
updateEnvelopeItemsMeta,
} from './update-envelope-items.types';
export const updateEnvelopeItemsRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/item/update-many',
summary: 'Update envelope items',
description: 'Update multiple envelope items for an envelope',
tags: ['Envelope Items'],
},
})
.meta(updateEnvelopeItemsMeta)
.input(ZUpdateEnvelopeItemsRequestSchema)
.output(ZUpdateEnvelopeItemsResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -102,6 +95,6 @@ export const updateEnvelopeItemsRoute = authenticatedProcedure
// Todo: Envelope [AUDIT_LOGS]
return {
updatedEnvelopeItems,
data: updatedEnvelopeItems,
};
});

13
packages/trpc/server/envelope-router/update-envelope-items.types.ts
View File

@ -3,6 +3,17 @@ import { z } from 'zod';
import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
import { ZDocumentTitleSchema } from '../document-router/schema';
import type { TrpcRouteMeta } from '../trpc';
export const updateEnvelopeItemsMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/item/update-many',
summary: 'Update envelope items',
description: 'Update multiple envelope items for an envelope',
tags: ['Envelope Items'],
},
};
export const ZUpdateEnvelopeItemsRequestSchema = z.object({
envelopeId: z.string(),
@ -17,7 +28,7 @@ export const ZUpdateEnvelopeItemsRequestSchema = z.object({
});
export const ZUpdateEnvelopeItemsResponseSchema = z.object({
updatedEnvelopeItems: EnvelopeItemSchema.pick({
data: EnvelopeItemSchema.pick({
id: true,
order: true,
title: true,

10
packages/trpc/server/envelope-router/update-envelope.ts
View File

@ -4,17 +4,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZUpdateEnvelopeRequestSchema,
ZUpdateEnvelopeResponseSchema,
updateEnvelopeMeta,
} from './update-envelope.types';
export const updateEnvelopeRoute = authenticatedProcedure
.meta({
openapi: {
method: 'POST',
path: '/envelope/update',
summary: 'Update envelope',
tags: ['Envelope'],
},
})
.meta(updateEnvelopeMeta)
.input(ZUpdateEnvelopeRequestSchema)
.output(ZUpdateEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {

10
packages/trpc/server/envelope-router/update-envelope.types.ts
View File

@ -12,6 +12,16 @@ import {
ZDocumentTitleSchema,
ZDocumentVisibilitySchema,
} from '../document-router/schema';
import type { TrpcRouteMeta } from '../trpc';
export const updateEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/update',
summary: 'Update envelope',
tags: ['Envelope'],
},
};
export const ZUpdateEnvelopeRequestSchema = z.object({
envelopeId: z.string(),