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

Merge branch 'main' into feat/unlink-documents-deleted-org

Browse Source
This commit is contained in:
Catalin Pit
2025-11-24 12:16:13 +02:00
committed by GitHub
parent bf6f09194d ae31860b16
commit c8c2a3b958
582 changed files with 77147 additions and 83710 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
packages/trpc/client/index.ts
View File

@ -1,17 +1,23 @@
import { createTRPCClient, httpBatchLink, httpLink, splitLink } from '@trpc/client';
import SuperJSON from 'superjson';
import {
createTRPCClient,
httpBatchLink,
httpLink,
isNonJsonSerializable,
splitLink,
} from '@trpc/client';
import { getBaseUrl } from '@documenso/lib/universal/get-base-url';
import type { AppRouter } from '../server/router';
import { dataTransformer } from '../utils/data-transformer';
export const trpc = createTRPCClient<AppRouter>({
links: [
splitLink({
condition: (op) => op.context.skipBatch === true,
condition: (op) => op.context.skipBatch === true || isNonJsonSerializable(op.input),
true: httpLink({
url: `${getBaseUrl()}/api/trpc`,
transformer: SuperJSON,
transformer: dataTransformer,
headers: (opts) => {
if (typeof opts.op.context.teamId === 'string') {
return {
@ -24,7 +30,7 @@ export const trpc = createTRPCClient<AppRouter>({
}),
false: httpBatchLink({
url: `${getBaseUrl()}/api/trpc`,
transformer: SuperJSON,
transformer: dataTransformer,
headers: (opts) => {
const operationWithTeamId = opts.opList.find(
(op) => op.context.teamId && typeof op.context.teamId === 'string',

28
packages/trpc/package.json
View File

@ -12,15 +12,21 @@
"dependencies": {
"@documenso/lib": "*",
"@documenso/prisma": "*",
"@tanstack/react-query": "5.59.15",
"@trpc/client": "11.0.0-rc.648",
"@trpc/react-query": "11.0.0-rc.648",
"@trpc/server": "11.0.0-rc.648",
"@ts-rest/core": "^3.30.5",
"luxon": "^3.4.0",
"superjson": "^1.13.1",
"trpc-to-openapi": "2.0.4",
"ts-pattern": "^5.0.5",
"zod": "3.24.1"
"@tanstack/react-query": "5.90.10",
"@trpc/client": "11.7.1",
"@trpc/react-query": "11.7.1",
"@trpc/server": "11.7.1",
"@ts-rest/core": "^3.52.1",
"formidable": "^3.5.4",
"luxon": "^3.7.2",
"superjson": "^2.2.5",
"trpc-to-openapi": "2.4.0",
"ts-pattern": "^5.9.0",
"zod": "^3.25.76",
"zod-form-data": "^2.0.8",
"zod-openapi": "^4.2.4"
},
"devDependencies": {
"@types/formidable": "^3.4.6"
}
}
}

10
packages/trpc/react/index.tsx
View File

@ -1,13 +1,13 @@
import { useMemo, useState } from 'react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { httpBatchLink, httpLink, splitLink } from '@trpc/client';
import { httpBatchLink, httpLink, isNonJsonSerializable, splitLink } from '@trpc/client';
import { createTRPCReact } from '@trpc/react-query';
import SuperJSON from 'superjson';
import { getBaseUrl } from '@documenso/lib/universal/get-base-url';
import type { AppRouter } from '../server/router';
import { dataTransformer } from '../utils/data-transformer';
export { getQueryKey } from '@trpc/react-query';
@ -44,16 +44,16 @@ export function TrpcProvider({ children, headers }: TrpcProviderProps) {
trpc.createClient({
links: [
splitLink({
condition: (op) => op.context.skipBatch === true,
condition: (op) => op.context.skipBatch === true || isNonJsonSerializable(op.input),
true: httpLink({
url: `${getBaseUrl()}/api/trpc`,
headers,
transformer: SuperJSON,
transformer: dataTransformer,
}),
false: httpBatchLink({
url: `${getBaseUrl()}/api/trpc`,
headers,
transformer: SuperJSON,
transformer: dataTransformer,
}),
}),
],

5
packages/trpc/server/admin-router/get-admin-organisation.ts
View File

@ -39,6 +39,11 @@ export const getAdminOrganisation = async ({ organisationId }: GetOrganisationOp
teams: true,
members: {
include: {
organisationGroupMembers: {
include: {
group: true,
},
},
user: {
select: {
id: true,

14
packages/trpc/server/admin-router/get-admin-organisation.types.ts
View File

@ -3,6 +3,8 @@ import { z } from 'zod';
import { ZOrganisationSchema } from '@documenso/lib/types/organisation';
import OrganisationClaimSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationClaimSchema';
import OrganisationGlobalSettingsSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGlobalSettingsSchema';
import OrganisationGroupMemberSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGroupMemberSchema';
import OrganisationGroupSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationGroupSchema';
import OrganisationMemberSchema from '@documenso/prisma/generated/zod/modelSchema/OrganisationMemberSchema';
import SubscriptionSchema from '@documenso/prisma/generated/zod/modelSchema/SubscriptionSchema';
import TeamSchema from '@documenso/prisma/generated/zod/modelSchema/TeamSchema';
@ -30,6 +32,18 @@ export const ZGetAdminOrganisationResponseSchema = ZOrganisationSchema.extend({
email: true,
name: true,
}),
organisationGroupMembers: z.array(
OrganisationGroupMemberSchema.pick({
id: true,
groupId: true,
}).extend({
group: OrganisationGroupSchema.pick({
id: true,
type: true,
organisationRole: true,
}),
}),
),
}).array(),
subscription: SubscriptionSchema.nullable(),
organisationClaim: OrganisationClaimSchema,

2
packages/trpc/server/admin-router/router.ts
View File

@ -17,6 +17,7 @@ import { promoteMemberToOwnerRoute } from './promote-member-to-owner';
import { resealDocumentRoute } from './reseal-document';
import { resetTwoFactorRoute } from './reset-two-factor-authentication';
import { updateAdminOrganisationRoute } from './update-admin-organisation';
import { updateOrganisationMemberRoleRoute } from './update-organisation-member-role';
import { updateRecipientRoute } from './update-recipient';
import { updateSiteSettingRoute } from './update-site-setting';
import { updateSubscriptionClaimRoute } from './update-subscription-claim';
@ -31,6 +32,7 @@ export const adminRouter = router({
},
organisationMember: {
promoteToOwner: promoteMemberToOwnerRoute,
updateRole: updateOrganisationMemberRoleRoute,
},
claims: {
find: findSubscriptionClaimsRoute,

220
packages/trpc/server/admin-router/update-organisation-member-role.ts Normal file
View File

@ -0,0 +1,220 @@
import { OrganisationGroupType, OrganisationMemberRole } from '@prisma/client';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { generateDatabaseId } from '@documenso/lib/universal/id';
import { getHighestOrganisationRoleInGroup } from '@documenso/lib/utils/organisations';
import { prisma } from '@documenso/prisma';
import { adminProcedure } from '../trpc';
import {
ZUpdateOrganisationMemberRoleRequestSchema,
ZUpdateOrganisationMemberRoleResponseSchema,
} from './update-organisation-member-role.types';
/**
* Admin mutation to update organisation member role or transfer ownership.
*
* This mutation handles two scenarios:
* 1. When role='OWNER': Transfers organisation ownership and promotes to ADMIN
* 2. When role=ADMIN/MANAGER/MEMBER: Updates group membership
*
* Admin privileges bypass normal hierarchy restrictions.
*/
export const updateOrganisationMemberRoleRoute = adminProcedure
.input(ZUpdateOrganisationMemberRoleRequestSchema)
.output(ZUpdateOrganisationMemberRoleResponseSchema)
.mutation(async ({ input, ctx }) => {
const { organisationId, userId, role } = input;
ctx.logger.info({
input: {
organisationId,
userId,
role,
},
});
const organisation = await prisma.organisation.findUnique({
where: {
id: organisationId,
},
include: {
groups: {
where: {
type: OrganisationGroupType.INTERNAL_ORGANISATION,
},
},
members: {
where: {
userId,
},
include: {
organisationGroupMembers: {
include: {
group: true,
},
},
},
},
},
});
if (!organisation) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'Organisation not found',
});
}
const [member] = organisation.members;
if (!member) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'User is not a member of this organisation',
});
}
const currentOrganisationRole = getHighestOrganisationRoleInGroup(
member.organisationGroupMembers.flatMap((member) => member.group),
);
if (role === 'OWNER') {
if (organisation.ownerUserId === userId) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'User is already the owner of this organisation',
});
}
const currentMemberGroup = organisation.groups.find(
(group) => group.organisationRole === currentOrganisationRole,
);
const adminGroup = organisation.groups.find(
(group) => group.organisationRole === OrganisationMemberRole.ADMIN,
);
if (!currentMemberGroup) {
ctx.logger.error({
message: '[CRITICAL]: Missing internal group',
organisationId,
userId,
role: currentOrganisationRole,
});
throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
message: 'Current member group not found',
});
}
if (!adminGroup) {
ctx.logger.error({
message: '[CRITICAL]: Missing internal group',
organisationId,
userId,
targetRole: 'ADMIN',
});
throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
message: 'Admin group not found',
});
}
await prisma.$transaction(async (tx) => {
await tx.organisation.update({
where: {
id: organisationId,
},
data: {
ownerUserId: userId,
},
});
if (currentOrganisationRole !== OrganisationMemberRole.ADMIN) {
await tx.organisationGroupMember.delete({
where: {
organisationMemberId_groupId: {
organisationMemberId: member.id,
groupId: currentMemberGroup.id,
},
},
});
await tx.organisationGroupMember.create({
data: {
id: generateDatabaseId('group_member'),
organisationMemberId: member.id,
groupId: adminGroup.id,
},
});
}
});
return;
}
const targetRole = role as OrganisationMemberRole;
if (currentOrganisationRole === targetRole) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'User already has this role',
});
}
if (userId === organisation.ownerUserId && targetRole !== OrganisationMemberRole.ADMIN) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Organisation owner must be an admin. Transfer ownership first.',
});
}
const currentMemberGroup = organisation.groups.find(
(group) => group.organisationRole === currentOrganisationRole,
);
const newMemberGroup = organisation.groups.find(
(group) => group.organisationRole === targetRole,
);
if (!currentMemberGroup) {
ctx.logger.error({
message: '[CRITICAL]: Missing internal group',
organisationId,
userId,
role: currentOrganisationRole,
});
throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
message: 'Current member group not found',
});
}
if (!newMemberGroup) {
ctx.logger.error({
message: '[CRITICAL]: Missing internal group',
organisationId,
userId,
targetRole,
});
throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
message: 'New member group not found',
});
}
await prisma.$transaction(async (tx) => {
await tx.organisationGroupMember.delete({
where: {
organisationMemberId_groupId: {
organisationMemberId: member.id,
groupId: currentMemberGroup.id,
},
},
});
await tx.organisationGroupMember.create({
data: {
id: generateDatabaseId('group_member'),
organisationMemberId: member.id,
groupId: newMemberGroup.id,
},
});
});
});

30
packages/trpc/server/admin-router/update-organisation-member-role.types.ts Normal file
View File

@ -0,0 +1,30 @@
import { OrganisationMemberRole } from '@prisma/client';
import { z } from 'zod';
/**
* Admin-only role selection that includes OWNER as a special case.
* OWNER is not a database role but triggers ownership transfer.
*/
export const ZAdminRoleSelection = z.enum([
'OWNER',
OrganisationMemberRole.ADMIN,
OrganisationMemberRole.MANAGER,
OrganisationMemberRole.MEMBER,
]);
export type TAdminRoleSelection = z.infer<typeof ZAdminRoleSelection>;
export const ZUpdateOrganisationMemberRoleRequestSchema = z.object({
organisationId: z.string().min(1),
userId: z.number().min(1),
role: ZAdminRoleSelection,
});
export const ZUpdateOrganisationMemberRoleResponseSchema = z.void();
export type TUpdateOrganisationMemberRoleRequest = z.infer<
typeof ZUpdateOrganisationMemberRoleRequestSchema
>;
export type TUpdateOrganisationMemberRoleResponse = z.infer<
typeof ZUpdateOrganisationMemberRoleResponseSchema
>;

4
packages/trpc/server/context.ts
View File

@ -24,6 +24,7 @@ export const createTrpcContext = async ({
const { session, user } = await getOptionalSession(c);
const req = c.req.raw;
const res = c.res;
const requestMetadata = c.get('context').requestMetadata;
@ -54,6 +55,7 @@ export const createTrpcContext = async ({
user: null,
teamId,
req,
res,
metadata,
};
}
@ -64,6 +66,7 @@ export const createTrpcContext = async ({
user,
teamId,
req,
res,
metadata,
};
};
@ -80,6 +83,7 @@ export type TrpcContext = (
) & {
teamId: number | undefined;
req: Request;
res: Response;
metadata: ApiRequestMetadata;
logger: Logger;
};

6
packages/trpc/server/document-router/attachment/create-attachment.ts
View File

@ -41,10 +41,14 @@ export const createAttachmentRoute = authenticatedProcedure
type: EnvelopeType.DOCUMENT,
});
await createAttachment({
const attachment = await createAttachment({
envelopeId: envelope.id,
teamId,
userId,
data,
});
return {
id: attachment.id,
};
});

4
packages/trpc/server/document-router/attachment/create-attachment.types.ts
View File

@ -8,7 +8,9 @@ export const ZCreateAttachmentRequestSchema = z.object({
}),
});
export const ZCreateAttachmentResponseSchema = z.void();
export const ZCreateAttachmentResponseSchema = z.object({
id: z.string(),
});
export type TCreateAttachmentRequest = z.infer<typeof ZCreateAttachmentRequestSchema>;
export type TCreateAttachmentResponse = z.infer<typeof ZCreateAttachmentResponseSchema>;

3
packages/trpc/server/document-router/attachment/delete-attachment.ts
View File

@ -1,5 +1,6 @@
import { deleteAttachment } from '@documenso/lib/server-only/envelope-attachment/delete-attachment';
import { ZGenericSuccessResponse } from '../../schema';
import { authenticatedProcedure } from '../../trpc';
import {
ZDeleteAttachmentRequestSchema,
@ -33,4 +34,6 @@ export const deleteAttachmentRoute = authenticatedProcedure
userId,
teamId,
});
return ZGenericSuccessResponse;
});

4
packages/trpc/server/document-router/attachment/delete-attachment.types.ts
View File

@ -1,10 +1,12 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../../schema';
export const ZDeleteAttachmentRequestSchema = z.object({
id: z.string(),
});
export const ZDeleteAttachmentResponseSchema = z.void();
export const ZDeleteAttachmentResponseSchema = ZSuccessResponseSchema;
export type TDeleteAttachmentRequest = z.infer<typeof ZDeleteAttachmentRequestSchema>;
export type TDeleteAttachmentResponse = z.infer<typeof ZDeleteAttachmentResponseSchema>;

3
packages/trpc/server/document-router/attachment/update-attachment.ts
View File

@ -1,5 +1,6 @@
import { updateAttachment } from '@documenso/lib/server-only/envelope-attachment/update-attachment';
import { ZGenericSuccessResponse } from '../../schema';
import { authenticatedProcedure } from '../../trpc';
import {
ZUpdateAttachmentRequestSchema,
@ -34,4 +35,6 @@ export const updateAttachmentRoute = authenticatedProcedure
teamId,
data,
});
return ZGenericSuccessResponse;
});

4
packages/trpc/server/document-router/attachment/update-attachment.types.ts
View File

@ -1,5 +1,7 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../../schema';
export const ZUpdateAttachmentRequestSchema = z.object({
id: z.string(),
data: z.object({
@ -8,7 +10,7 @@ export const ZUpdateAttachmentRequestSchema = z.object({
}),
});
export const ZUpdateAttachmentResponseSchema = z.void();
export const ZUpdateAttachmentResponseSchema = ZSuccessResponseSchema;
export type TUpdateAttachmentRequest = z.infer<typeof ZUpdateAttachmentRequestSchema>;
export type TUpdateAttachmentResponse = z.infer<typeof ZUpdateAttachmentResponseSchema>;

61
packages/trpc/server/document-router/create-document.ts
View File

@ -3,20 +3,54 @@ import { EnvelopeType } from '@prisma/client';
import { getServerLimits } from '@documenso/ee/server-only/limits/server';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { createEnvelope } from '@documenso/lib/server-only/envelope/create-envelope';
import { insertFormValuesInPdf } from '@documenso/lib/server-only/pdf/insert-form-values-in-pdf';
import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
import { mapSecondaryIdToDocumentId } from '@documenso/lib/utils/envelope';
import { authenticatedProcedure } from '../trpc';
import {
ZCreateDocumentRequestSchema,
ZCreateDocumentResponseSchema,
createDocumentMeta,
} from './create-document.types';
export const createDocumentRoute = authenticatedProcedure
.input(ZCreateDocumentRequestSchema) // Note: Before releasing this to public, update the response schema to be correct.
.meta(createDocumentMeta)
.input(ZCreateDocumentRequestSchema)
.output(ZCreateDocumentResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId } = ctx;
const { title, documentDataId, timezone, folderId, attachments } = input;
const { payload, file } = input;
const {
title,
externalId,
visibility,
globalAccessAuth,
globalActionAuth,
recipients,
meta,
folderId,
formValues,
attachments,
} = payload;
let pdf = Buffer.from(await file.arrayBuffer());
if (formValues) {
// eslint-disable-next-line require-atomic-updates
pdf = await insertFormValuesInPdf({
pdf,
formValues,
});
}
const { id: documentDataId } = await putNormalizedPdfFileServerSide({
name: file.name,
type: 'application/pdf',
arrayBuffer: async () => Promise.resolve(pdf),
});
ctx.logger.info({
input: {
@ -40,7 +74,20 @@ export const createDocumentRoute = authenticatedProcedure
data: {
type: EnvelopeType.DOCUMENT,
title,
userTimezone: timezone,
externalId,
visibility,
globalAccessAuth,
globalActionAuth,
recipients: (recipients || []).map((recipient) => ({
...recipient,
fields: (recipient.fields || []).map((field) => ({
...field,
page: field.pageNumber,
positionX: field.pageX,
positionY: field.pageY,
documentDataId,
})),
})),
folderId,
envelopeItems: [
{
@ -50,11 +97,15 @@ export const createDocumentRoute = authenticatedProcedure
],
},
attachments,
normalizePdf: true,
meta: {
...meta,
emailSettings: meta?.emailSettings ?? undefined,
},
requestMetadata: ctx.metadata,
});
return {
legacyDocumentId: mapSecondaryIdToDocumentId(document.secondaryId),
envelopeId: document.id,
id: mapSecondaryIdToDocumentId(document.secondaryId),
};
});

85
packages/trpc/server/document-router/create-document.types.ts
View File

@ -1,25 +1,70 @@
import { z } from 'zod';
import { zfd } from 'zod-form-data';
import { ZDocumentMetaTimezoneSchema } from '@documenso/lib/types/document-meta';
import {
ZDocumentAccessAuthTypesSchema,
ZDocumentActionAuthTypesSchema,
} from '@documenso/lib/types/document-auth';
import { ZDocumentFormValuesSchema } from '@documenso/lib/types/document-form-values';
import { ZDocumentMetaCreateSchema } from '@documenso/lib/types/document-meta';
import { ZDocumentVisibilitySchema } from '@documenso/lib/types/document-visibility';
import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
import {
ZFieldHeightSchema,
ZFieldPageNumberSchema,
ZFieldPageXSchema,
ZFieldPageYSchema,
ZFieldWidthSchema,
} from '@documenso/lib/types/field';
import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
import { ZDocumentTitleSchema } from './schema';
import { zodFormData } from '../../utils/zod-form-data';
import { ZCreateRecipientSchema } from '../recipient-router/schema';
import type { TrpcRouteMeta } from '../trpc';
import { ZDocumentExternalIdSchema, ZDocumentTitleSchema } from './schema';
// Currently not in use until we allow passthrough documents on create.
// export const createDocumentMeta: TrpcRouteMeta = {
// openapi: {
// method: 'POST',
// path: '/document/create',
// summary: 'Create document',
// tags: ['Document'],
// },
// };
export const createDocumentMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/document/create',
contentTypes: ['multipart/form-data'],
summary: 'Create document',
description: 'Create a document using form data.',
tags: ['Document'],
},
};
export const ZCreateDocumentRequestSchema = z.object({
export const ZCreateDocumentPayloadSchema = z.object({
title: ZDocumentTitleSchema,
documentDataId: z.string().min(1),
timezone: ZDocumentMetaTimezoneSchema.optional(),
folderId: z.string().describe('The ID of the folder to create the document in').optional(),
externalId: ZDocumentExternalIdSchema.optional(),
visibility: ZDocumentVisibilitySchema.optional(),
globalAccessAuth: z.array(ZDocumentAccessAuthTypesSchema).optional(),
globalActionAuth: z.array(ZDocumentActionAuthTypesSchema).optional(),
formValues: ZDocumentFormValuesSchema.optional(),
folderId: z
.string()
.describe(
'The ID of the folder to create the document in. If not provided, the document will be created in the root folder.',
)
.optional(),
recipients: z
.array(
ZCreateRecipientSchema.extend({
fields: ZFieldAndMetaSchema.and(
z.object({
pageNumber: ZFieldPageNumberSchema,
pageX: ZFieldPageXSchema,
pageY: ZFieldPageYSchema,
width: ZFieldWidthSchema,
height: ZFieldHeightSchema,
}),
)
.array()
.optional(),
}),
)
.optional(),
attachments: z
.array(
z.object({
@ -29,11 +74,19 @@ export const ZCreateDocumentRequestSchema = z.object({
}),
)
.optional(),
meta: ZDocumentMetaCreateSchema.optional(),
});
export const ZCreateDocumentRequestSchema = zodFormData({
payload: zfd.json(ZCreateDocumentPayloadSchema),
file: zfd.file(),
});
export const ZCreateDocumentResponseSchema = z.object({
legacyDocumentId: z.number(),
envelopeId: z.string(),
id: z.number(),
});
export type TCreateDocumentPayloadSchema = z.infer<typeof ZCreateDocumentPayloadSchema>;
export type TCreateDocumentRequest = z.infer<typeof ZCreateDocumentRequestSchema>;
export type TCreateDocumentResponse = z.infer<typeof ZCreateDocumentResponseSchema>;

2
packages/trpc/server/document-router/delete-document.ts
View File

@ -1,12 +1,12 @@
import { deleteDocument } from '@documenso/lib/server-only/document/delete-document';
import { ZGenericSuccessResponse } from '../schema';
import { authenticatedProcedure } from '../trpc';
import {
ZDeleteDocumentRequestSchema,
ZDeleteDocumentResponseSchema,
deleteDocumentMeta,
} from './delete-document.types';
import { ZGenericSuccessResponse } from './schema';
export const deleteDocumentRoute = authenticatedProcedure
.meta(deleteDocumentMeta)

2
packages/trpc/server/document-router/delete-document.types.ts
View File

@ -1,7 +1,7 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../schema';
import type { TrpcRouteMeta } from '../trpc';
import { ZSuccessResponseSchema } from './schema';
export const deleteDocumentMeta: TrpcRouteMeta = {
openapi: {

96
packages/trpc/server/document-router/download-document-beta.ts Normal file
View File

@ -0,0 +1,96 @@
import type { DocumentData } from '@prisma/client';
import { DocumentDataType, EnvelopeType } from '@prisma/client';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
import { getPresignGetUrl } from '@documenso/lib/universal/upload/server-actions';
import { isDocumentCompleted } from '@documenso/lib/utils/document';
import { authenticatedProcedure } from '../trpc';
import {
ZDownloadDocumentRequestSchema,
ZDownloadDocumentResponseSchema,
downloadDocumentMeta,
} from './download-document-beta.types';
export const downloadDocumentBetaRoute = authenticatedProcedure
.meta(downloadDocumentMeta)
.input(ZDownloadDocumentRequestSchema)
.output(ZDownloadDocumentResponseSchema)
.query(async ({ input, ctx }) => {
const { teamId, user } = ctx;
const { documentId, version } = input;
ctx.logger.info({
input: {
documentId,
version,
},
});
const envelope = await getEnvelopeById({
id: {
type: 'documentId',
id: documentId,
},
type: EnvelopeType.DOCUMENT,
userId: user.id,
teamId,
});
// This error is done AFTER the get envelope so we can test access controls without S3.
if (process.env.NEXT_PUBLIC_UPLOAD_TRANSPORT !== 's3') {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Document downloads are only available when S3 storage is configured.',
});
}
const documentData: DocumentData | undefined = envelope.envelopeItems[0]?.documentData;
if (envelope.envelopeItems.length !== 1 || !documentData) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message:
'This endpoint only supports documents with a single item. Use envelopes API instead.',
});
}
if (documentData.type !== DocumentDataType.S3_PATH) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Document is not stored in S3 and cannot be downloaded via URL.',
});
}
if (version === 'signed' && !isDocumentCompleted(envelope.status)) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Document is not completed yet.',
});
}
try {
const data =
version === 'original' ? documentData.initialData || documentData.data : documentData.data;
const { url } = await getPresignGetUrl(data);
const baseTitle = envelope.title.replace(/\.pdf$/, '');
const suffix = version === 'signed' ? '_signed.pdf' : '.pdf';
const filename = `${baseTitle}${suffix}`;
return {
downloadUrl: url,
filename,
contentType: 'application/pdf',
};
} catch (error) {
ctx.logger.error({
error,
message: 'Failed to generate download URL',
documentId,
version,
});
throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
message: 'Failed to generate download URL',
});
}
});

32
packages/trpc/server/document-router/download-document-beta.types.ts Normal file
View File

@ -0,0 +1,32 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../trpc';
export const downloadDocumentMeta: TrpcRouteMeta = {
openapi: {
method: 'GET',
path: '/document/{documentId}/download-beta',
summary: 'Download document (beta)',
description: 'Get a pre-signed download URL for the original or signed version of a document',
tags: ['Document'],
},
};
export const ZDownloadDocumentRequestSchema = z.object({
documentId: z.number().describe('The ID of the document to download.'),
version: z
.enum(['original', 'signed'])
.describe(
'The version of the document to download. "signed" returns the completed document with signatures, "original" returns the original uploaded document.',
)
.default('signed'),
});
export const ZDownloadDocumentResponseSchema = z.object({
downloadUrl: z.string().describe('Pre-signed URL for downloading the PDF file'),
filename: z.string().describe('The filename of the PDF file'),
contentType: z.string().describe('MIME type of the file'),
});
export type TDownloadDocumentRequest = z.infer<typeof ZDownloadDocumentRequestSchema>;
export type TDownloadDocumentResponse = z.infer<typeof ZDownloadDocumentResponseSchema>;

78
packages/trpc/server/document-router/download-document.ts
View File

@ -1,11 +1,3 @@
import type { DocumentData } from '@prisma/client';
import { DocumentDataType, EnvelopeType } from '@prisma/client';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
import { getPresignGetUrl } from '@documenso/lib/universal/upload/server-actions';
import { isDocumentCompleted } from '@documenso/lib/utils/document';
import { authenticatedProcedure } from '../trpc';
import {
ZDownloadDocumentRequestSchema,
@ -17,8 +9,7 @@ export const downloadDocumentRoute = authenticatedProcedure
.meta(downloadDocumentMeta)
.input(ZDownloadDocumentRequestSchema)
.output(ZDownloadDocumentResponseSchema)
.query(async ({ input, ctx }) => {
const { teamId, user } = ctx;
.query(({ input, ctx }) => {
const { documentId, version } = input;
ctx.logger.info({
@ -28,69 +19,6 @@ export const downloadDocumentRoute = authenticatedProcedure
},
});
const envelope = await getEnvelopeById({
id: {
type: 'documentId',
id: documentId,
},
type: EnvelopeType.DOCUMENT,
userId: user.id,
teamId,
});
// This error is done AFTER the get envelope so we can test access controls without S3.
if (process.env.NEXT_PUBLIC_UPLOAD_TRANSPORT !== 's3') {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Document downloads are only available when S3 storage is configured.',
});
}
const documentData: DocumentData | undefined = envelope.envelopeItems[0]?.documentData;
if (envelope.envelopeItems.length !== 1 || !documentData) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message:
'This endpoint only supports documents with a single item. Use envelopes API instead.',
});
}
if (documentData.type !== DocumentDataType.S3_PATH) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Document is not stored in S3 and cannot be downloaded via URL.',
});
}
if (version === 'signed' && !isDocumentCompleted(envelope.status)) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Document is not completed yet.',
});
}
try {
const data =
version === 'original' ? documentData.initialData || documentData.data : documentData.data;
const { url } = await getPresignGetUrl(data);
const baseTitle = envelope.title.replace(/\.pdf$/, '');
const suffix = version === 'signed' ? '_signed.pdf' : '.pdf';
const filename = `${baseTitle}${suffix}`;
return {
downloadUrl: url,
filename,
contentType: 'application/pdf',
};
} catch (error) {
ctx.logger.error({
error,
message: 'Failed to generate download URL',
documentId,
version,
});
throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
message: 'Failed to generate download URL',
});
}
// This endpoint is purely for V2 API, which is implemented in the Hono remix server.
throw new Error('NOT_IMPLEMENTED');
});

14
packages/trpc/server/document-router/download-document.types.ts
View File

@ -5,10 +5,12 @@ import type { TrpcRouteMeta } from '../trpc';
export const downloadDocumentMeta: TrpcRouteMeta = {
openapi: {
method: 'GET',
path: '/document/{documentId}/download-beta',
summary: 'Download document (beta)',
description: 'Get a pre-signed download URL for the original or signed version of a document',
path: '/document/{documentId}/download',
summary: 'Download document',
tags: ['Document'],
responseHeaders: z.object({
'Content-Type': z.literal('application/pdf'),
}),
},
};
@ -22,11 +24,7 @@ export const ZDownloadDocumentRequestSchema = z.object({
.default('signed'),
});
export const ZDownloadDocumentResponseSchema = z.object({
downloadUrl: z.string().describe('Pre-signed URL for downloading the PDF file'),
filename: z.string().describe('The filename of the PDF file'),
contentType: z.string().describe('MIME type of the file'),
});
export const ZDownloadDocumentResponseSchema = z.instanceof(Uint8Array);
export type TDownloadDocumentRequest = z.infer<typeof ZDownloadDocumentRequestSchema>;
export type TDownloadDocumentResponse = z.infer<typeof ZDownloadDocumentResponseSchema>;

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

@ -92,6 +92,14 @@ export const findInbox = async ({ userId, page = 1, perPage = 10, orderBy }: Fin
url: true,
},
},
envelopeItems: {
select: {
id: true,
envelopeId: true,
title: true,
order: true,
},
},
},
}),
prisma.envelope.count({

2
packages/trpc/server/document-router/redistribute-document.ts
View File

@ -1,12 +1,12 @@
import { resendDocument } from '@documenso/lib/server-only/document/resend-document';
import { ZGenericSuccessResponse } from '../schema';
import { authenticatedProcedure } from '../trpc';
import {
ZRedistributeDocumentRequestSchema,
ZRedistributeDocumentResponseSchema,
redistributeDocumentMeta,
} from './redistribute-document.types';
import { ZGenericSuccessResponse } from './schema';
export const redistributeDocumentRoute = authenticatedProcedure
.meta(redistributeDocumentMeta)

2
packages/trpc/server/document-router/redistribute-document.types.ts
View File

@ -1,7 +1,7 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../schema';
import type { TrpcRouteMeta } from '../trpc';
import { ZSuccessResponseSchema } from './schema';
export const redistributeDocumentMeta: TrpcRouteMeta = {
openapi: {

5
packages/trpc/server/document-router/router.ts
View File

@ -10,6 +10,7 @@ import { deleteDocumentRoute } from './delete-document';
import { distributeDocumentRoute } from './distribute-document';
import { downloadDocumentRoute } from './download-document';
import { downloadDocumentAuditLogsRoute } from './download-document-audit-logs';
import { downloadDocumentBetaRoute } from './download-document-beta';
import { downloadDocumentCertificateRoute } from './download-document-certificate';
import { duplicateDocumentRoute } from './duplicate-document';
import { findDocumentAuditLogsRoute } from './find-document-audit-logs';
@ -37,8 +38,10 @@ export const documentRouter = router({
search: searchDocumentRoute,
share: shareDocumentRoute,
// Temporary v2 beta routes to be removed once V2 is fully released.
download: downloadDocumentRoute,
// Deprecated endpoints which need to be removed in the future.
downloadBeta: downloadDocumentBetaRoute,
createDocumentTemporary: createDocumentTemporaryRoute,
// Internal document routes for custom frontend requests.

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

@ -1,19 +1,6 @@
import { DocumentVisibility } from '@prisma/client';
import { z } from 'zod';
/**
* Required for empty responses since we currently can't 201 requests for our openapi setup.
*
* Without this it will throw an error in Speakeasy SDK when it tries to parse an empty response.
*/
export const ZSuccessResponseSchema = z.object({
success: z.literal(true),
});
export const ZGenericSuccessResponse = {
success: true,
} satisfies z.infer<typeof ZSuccessResponseSchema>;
export const ZDocumentTitleSchema = z
.string()
.trim()

3
packages/trpc/server/embedding-router/_router.ts
View File

@ -1,5 +1,4 @@
import { router } from '../trpc';
import { applyMultiSignSignatureRoute } from './apply-multi-sign-signature';
import { createEmbeddingDocumentRoute } from './create-embedding-document';
import { createEmbeddingPresignTokenRoute } from './create-embedding-presign-token';
import { createEmbeddingTemplateRoute } from './create-embedding-template';
@ -15,6 +14,6 @@ export const embeddingPresignRouter = router({
createEmbeddingTemplate: createEmbeddingTemplateRoute,
updateEmbeddingDocument: updateEmbeddingDocumentRoute,
updateEmbeddingTemplate: updateEmbeddingTemplateRoute,
applyMultiSignSignature: applyMultiSignSignatureRoute,
// applyMultiSignSignature: applyMultiSignSignatureRoute,
getMultiSignDocument: getMultiSignDocumentRoute,
});

43
packages/trpc/server/embedding-router/create-embedding-document.types.ts
View File

@ -21,33 +21,38 @@ import {
ZFieldWidthSchema,
} from '@documenso/lib/types/field';
import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
import { RecipientRole } from '@documenso/prisma/client';
import { DocumentSigningOrder } from '@documenso/prisma/generated/types';
import { ZDocumentExternalIdSchema, ZDocumentTitleSchema } from '../document-router/schema';
import { ZCreateRecipientSchema } from '../recipient-router/schema';
export const ZCreateEmbeddingDocumentRequestSchema = z.object({
title: ZDocumentTitleSchema,
documentDataId: z.string(),
externalId: ZDocumentExternalIdSchema.optional(),
recipients: z
.array(
ZCreateRecipientSchema.extend({
fields: ZFieldAndMetaSchema.and(
z.object({
pageNumber: ZFieldPageNumberSchema,
pageX: ZFieldPageXSchema,
pageY: ZFieldPageYSchema,
width: ZFieldWidthSchema,
height: ZFieldHeightSchema,
}),
)
.array()
.optional(),
}),
)
.optional(),
recipients: z.array(
z.object({
id: z.number().optional(),
email: z.string().email(),
name: z.string(),
role: z.nativeEnum(RecipientRole),
signingOrder: z.number().optional(),
// We have an any cast so any changes here you need to update it in the embeding document edit page
// Search: "map<any>" to find it
fields: ZFieldAndMetaSchema.and(
z.object({
id: z.number().optional(),
pageNumber: ZFieldPageNumberSchema,
pageX: ZFieldPageXSchema,
pageY: ZFieldPageYSchema,
width: ZFieldWidthSchema,
height: ZFieldHeightSchema,
}),
)
.array()
.optional(),
}),
),
meta: z
.object({
subject: ZDocumentMetaSubjectSchema.optional(),

35
packages/trpc/server/embedding-router/create-embedding-template.types.ts
View File

@ -1,4 +1,4 @@
import { DocumentSigningOrder, FieldType, RecipientRole } from '@prisma/client';
import { DocumentSigningOrder, RecipientRole } from '@prisma/client';
import { z } from 'zod';
import { ZDocumentEmailSettingsSchema } from '@documenso/lib/types/document-email';
@ -21,30 +21,33 @@ import {
ZFieldPageYSchema,
ZFieldWidthSchema,
} from '@documenso/lib/types/field';
import { ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
import { ZDocumentTitleSchema } from '../document-router/schema';
const ZFieldSchema = z.object({
type: z.nativeEnum(FieldType),
pageNumber: ZFieldPageNumberSchema,
pageX: ZFieldPageXSchema,
pageY: ZFieldPageYSchema,
width: ZFieldWidthSchema,
height: ZFieldHeightSchema,
fieldMeta: ZFieldMetaSchema.optional(),
});
export const ZCreateEmbeddingTemplateRequestSchema = z.object({
title: ZDocumentTitleSchema,
documentDataId: z.string(),
recipients: z.array(
z.object({
email: z.string().email(),
name: z.string().optional(),
role: z.nativeEnum(RecipientRole).optional(),
email: z.union([z.string().length(0), z.string().email()]),
name: z.string(),
role: z.nativeEnum(RecipientRole),
signingOrder: z.number().optional(),
fields: z.array(ZFieldSchema).optional(),
// We have an any cast so any changes here you need to update it in the embeding document edit page
// Search: "map<any>" to find it
fields: ZFieldAndMetaSchema.and(
z.object({
id: z.number().optional(),
pageNumber: ZFieldPageNumberSchema,
pageX: ZFieldPageXSchema,
pageY: ZFieldPageYSchema,
width: ZFieldWidthSchema,
height: ZFieldHeightSchema,
}),
)
.array()
.optional(),
}),
),
meta: z

5
packages/trpc/server/embedding-router/get-multi-sign-document.types.ts
View File

@ -4,6 +4,7 @@ import { ZDocumentLiteSchema } from '@documenso/lib/types/document';
import { ZRecipientLiteSchema } from '@documenso/lib/types/recipient';
import DocumentDataSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentDataSchema';
import DocumentMetaSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentMetaSchema';
import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
import FieldSchema from '@documenso/prisma/generated/zod/modelSchema/FieldSchema';
import SignatureSchema from '@documenso/prisma/generated/zod/modelSchema/SignatureSchema';
@ -40,6 +41,10 @@ export const ZGetMultiSignDocumentResponseSchema = ZDocumentLiteSchema.extend({
signature: SignatureSchema.nullable(),
}),
),
envelopeItems: EnvelopeItemSchema.pick({
id: true,
envelopeId: true,
}).array(),
});
export type TGetMultiSignDocumentRequestSchema = z.infer<typeof ZGetMultiSignDocumentRequestSchema>;

2
packages/trpc/server/embedding-router/update-embedding-document.types.ts
View File

@ -32,7 +32,7 @@ export const ZUpdateEmbeddingDocumentRequestSchema = z.object({
recipients: z.array(
z.object({
id: z.number().optional(),
email: z.string().toLowerCase().email().min(1),
email: z.string().email(),
name: z.string(),
role: z.nativeEnum(RecipientRole),
signingOrder: z.number().optional(),

14
packages/trpc/server/embedding-router/update-embedding-template.ts
View File

@ -3,7 +3,6 @@ import { verifyEmbeddingPresignToken } from '@documenso/lib/server-only/embeddin
import { updateEnvelope } from '@documenso/lib/server-only/envelope/update-envelope';
import { setFieldsForTemplate } from '@documenso/lib/server-only/field/set-fields-for-template';
import { setTemplateRecipients } from '@documenso/lib/server-only/recipient/set-template-recipients';
import { nanoid } from '@documenso/lib/universal/id';
import { procedure } from '../trpc';
import {
@ -53,11 +52,6 @@ export const updateEmbeddingTemplateRoute = procedure
requestMetadata: ctx.metadata,
});
const recipientsWithClientId = recipients.map((recipient) => ({
...recipient,
clientId: nanoid(),
}));
const { recipients: updatedRecipients } = await setTemplateRecipients({
userId: apiToken.userId,
teamId: apiToken.teamId ?? undefined,
@ -65,7 +59,7 @@ export const updateEmbeddingTemplateRoute = procedure
type: 'templateId',
id: templateId,
},
recipients: recipientsWithClientId.map((recipient) => ({
recipients: recipients.map((recipient) => ({
id: recipient.id,
email: recipient.email,
name: recipient.name ?? '',
@ -74,8 +68,8 @@ export const updateEmbeddingTemplateRoute = procedure
})),
});
const fields = recipientsWithClientId.flatMap((recipient) => {
const recipientId = updatedRecipients.find((r) => r.email === recipient.email)?.id;
const fields = recipients.flatMap((recipient) => {
const recipientId = updatedRecipients.find((r) => r.id === recipient.id)?.id;
if (!recipientId) {
throw new AppError(AppErrorCode.UNKNOWN_ERROR, {
@ -86,8 +80,6 @@ export const updateEmbeddingTemplateRoute = procedure
return (recipient.fields ?? []).map((field) => ({
...field,
recipientId,
// !: Temp property to be removed once we don't link based on signer email
signerEmail: recipient.email,
}));
});

24
packages/trpc/server/embedding-router/update-embedding-template.types.ts
View File

@ -21,7 +21,7 @@ import {
ZFieldPageYSchema,
ZFieldWidthSchema,
} from '@documenso/lib/types/field';
import { ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
import { ZFieldAndMetaSchema, ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
import { ZDocumentTitleSchema } from '../document-router/schema';
@ -44,11 +44,25 @@ export const ZUpdateEmbeddingTemplateRequestSchema = z.object({
recipients: z.array(
z.object({
id: z.number().optional(),
email: z.string().email(),
name: z.string().optional(),
role: z.nativeEnum(RecipientRole).optional(),
email: z.union([z.string().length(0), z.string().email()]),
name: z.string(),
role: z.nativeEnum(RecipientRole),
signingOrder: z.number().optional(),
fields: z.array(ZFieldSchema).optional(),
// We have an any cast so any changes here you need to update it in the embeding document edit page
// Search: "map<any>" to find it
fields: ZFieldAndMetaSchema.and(
z.object({
id: z.number().optional(),
pageNumber: ZFieldPageNumberSchema,
pageX: ZFieldPageXSchema,
pageY: ZFieldPageYSchema,
width: ZFieldWidthSchema,
height: ZFieldHeightSchema,
envelopeItemId: z.string(),
}),
)
.array()
.optional(),
}),
),
meta: z

2
packages/trpc/server/enterprise-router/create-subscription.ts
View File

@ -71,7 +71,7 @@ export const createSubscriptionRoute = authenticatedProcedure
}
const returnUrl = isPersonalLayoutMode
? `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing`
? `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing-personal`
: `${NEXT_PUBLIC_WEBAPP_URL()}/o/${organisation.url}/settings/billing`;
const redirectUrl = await createCheckoutSession({

8
packages/trpc/server/enterprise-router/manage-subscription.ts
View File

@ -12,7 +12,7 @@ import { ZManageSubscriptionRequestSchema } from './manage-subscription.types';
export const manageSubscriptionRoute = authenticatedProcedure
.input(ZManageSubscriptionRequestSchema)
.mutation(async ({ ctx, input }) => {
const { organisationId } = input;
const { organisationId, isPersonalLayoutMode } = input;
ctx.logger.info({
input: {
@ -93,9 +93,13 @@ export const manageSubscriptionRoute = authenticatedProcedure
});
}
const returnUrl = isPersonalLayoutMode
? `${NEXT_PUBLIC_WEBAPP_URL()}/settings/billing-personal`
: `${NEXT_PUBLIC_WEBAPP_URL()}/o/${organisation.url}/settings/billing`;
const redirectUrl = await getPortalSession({
customerId,
returnUrl: `${NEXT_PUBLIC_WEBAPP_URL()}/o/${organisation.url}/settings/billing`,
returnUrl,
});
return {

1
packages/trpc/server/enterprise-router/manage-subscription.types.ts
View File

@ -2,4 +2,5 @@ import { z } from 'zod';
export const ZManageSubscriptionRequestSchema = z.object({
organisationId: z.string().describe('The organisation to manage the subscription for'),
isPersonalLayoutMode: z.boolean().optional(),
});

17
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'],
},
})
.meta(createAttachmentMeta)
.input(ZCreateAttachmentRequestSchema)
.output(ZCreateAttachmentResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -28,10 +21,14 @@ export const createAttachmentRoute = authenticatedProcedure
input: { envelopeId, label: data.label },
});
await createAttachment({
const attachment = await createAttachment({
envelopeId,
teamId,
userId,
data,
});
return {
id: attachment.id,
};
});

16
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({
@ -8,7 +20,9 @@ export const ZCreateAttachmentRequestSchema = z.object({
}),
});
export const ZCreateAttachmentResponseSchema = z.void();
export const ZCreateAttachmentResponseSchema = z.object({
id: z.string(),
});
export type TCreateAttachmentRequest = z.infer<typeof ZCreateAttachmentRequestSchema>;
export type TCreateAttachmentResponse = z.infer<typeof ZCreateAttachmentResponseSchema>;

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

@ -1,21 +1,15 @@
import { deleteAttachment } from '@documenso/lib/server-only/envelope-attachment/delete-attachment';
import { ZGenericSuccessResponse } from '../../schema';
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'],
},
})
.meta(deleteAttachmentMeta)
.input(ZDeleteAttachmentRequestSchema)
.output(ZDeleteAttachmentResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -33,4 +27,6 @@ export const deleteAttachmentRoute = authenticatedProcedure
userId,
teamId,
});
return ZGenericSuccessResponse;
});

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

@ -1,10 +1,23 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../../schema';
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(),
});
export const ZDeleteAttachmentResponseSchema = z.void();
export const ZDeleteAttachmentResponseSchema = ZSuccessResponseSchema;
export type TDeleteAttachmentRequest = z.infer<typeof ZDeleteAttachmentRequestSchema>;
export type TDeleteAttachmentResponse = z.infer<typeof ZDeleteAttachmentResponseSchema>;

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

@ -2,22 +2,15 @@ import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { findAttachmentsByEnvelopeId } from '@documenso/lib/server-only/envelope-attachment/find-attachments-by-envelope-id';
import { findAttachmentsByToken } from '@documenso/lib/server-only/envelope-attachment/find-attachments-by-token';
import { procedure } from '../../trpc';
import { maybeAuthenticatedProcedure } from '../../trpc';
import {
ZFindAttachmentsRequestSchema,
ZFindAttachmentsResponseSchema,
findAttachmentsMeta,
} from './find-attachments.types';
export const findAttachmentsRoute = procedure
.meta({
openapi: {
method: 'GET',
path: '/envelope/attachment',
summary: 'Find attachments',
description: 'Find all attachments for an envelope',
tags: ['Envelope'],
},
})
export const findAttachmentsRoute = maybeAuthenticatedProcedure
.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(),

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

@ -1,21 +1,15 @@
import { updateAttachment } from '@documenso/lib/server-only/envelope-attachment/update-attachment';
import { ZGenericSuccessResponse } from '../../schema';
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'],
},
})
.meta(updateAttachmentMeta)
.input(ZUpdateAttachmentRequestSchema)
.output(ZUpdateAttachmentResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -34,4 +28,6 @@ export const updateAttachmentRoute = authenticatedProcedure
teamId,
data,
});
return ZGenericSuccessResponse;
});

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

@ -1,5 +1,18 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../../schema';
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({
@ -8,7 +21,7 @@ export const ZUpdateAttachmentRequestSchema = z.object({
}),
});
export const ZUpdateAttachmentResponseSchema = z.void();
export const ZUpdateAttachmentResponseSchema = ZSuccessResponseSchema;
export type TUpdateAttachmentRequest = z.infer<typeof ZUpdateAttachmentRequestSchema>;
export type TUpdateAttachmentResponse = z.infer<typeof ZUpdateAttachmentResponseSchema>;

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

@ -2,6 +2,7 @@ import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { getEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
import { prefixedId } from '@documenso/lib/universal/id';
import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
import { canEnvelopeItemsBeModified } from '@documenso/lib/utils/envelope';
import { prisma } from '@documenso/prisma';
@ -10,14 +11,17 @@ import { authenticatedProcedure } from '../trpc';
import {
ZCreateEnvelopeItemsRequestSchema,
ZCreateEnvelopeItemsResponseSchema,
createEnvelopeItemsMeta,
} from './create-envelope-items.types';
export const createEnvelopeItemsRoute = authenticatedProcedure
.meta(createEnvelopeItemsMeta)
.input(ZCreateEnvelopeItemsRequestSchema)
.output(ZCreateEnvelopeItemsResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId, metadata } = ctx;
const { envelopeId, items } = input;
const { payload, files } = input;
const { envelopeId } = payload;
ctx.logger.info({
input: {
@ -71,7 +75,7 @@ export const createEnvelopeItemsRoute = authenticatedProcedure
const organisationClaim = envelope.team.organisation.organisationClaim;
const remainingEnvelopeItems =
organisationClaim.envelopeItemCount - envelope.envelopeItems.length - items.length;
organisationClaim.envelopeItemCount - envelope.envelopeItems.length - files.length;
if (remainingEnvelopeItems < 0) {
throw new AppError('ENVELOPE_ITEM_LIMIT_EXCEEDED', {
@ -80,41 +84,24 @@ export const createEnvelopeItemsRoute = authenticatedProcedure
});
}
const foundDocumentData = await prisma.documentData.findMany({
where: {
id: {
in: items.map((item) => item.documentDataId),
},
},
select: {
envelopeItem: {
select: {
id: true,
},
},
},
});
// For each file, stream to s3 and create the document data.
const envelopeItems = await Promise.all(
files.map(async (file) => {
const { id: documentDataId } = await putNormalizedPdfFileServerSide(file);
// Check that all the document data was found.
if (foundDocumentData.length !== items.length) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'Document data not found',
});
}
// Check that it doesn't already have an envelope item.
if (foundDocumentData.some((documentData) => documentData.envelopeItem?.id)) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Document data not found',
});
}
return {
title: file.name,
documentDataId,
};
}),
);
const currentHighestOrderValue =
envelope.envelopeItems[envelope.envelopeItems.length - 1]?.order ?? 1;
const result = await prisma.$transaction(async (tx) => {
const createdItems = await tx.envelopeItem.createManyAndReturn({
data: items.map((item) => ({
data: envelopeItems.map((item) => ({
id: prefixedId('envelope_item'),
envelopeId,
title: item.title,
@ -148,6 +135,6 @@ export const createEnvelopeItemsRoute = authenticatedProcedure
});
return {
createdEnvelopeItems: result,
data: result,
};
});

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

@ -1,38 +1,41 @@
import { z } from 'zod';
import { zfd } from 'zod-form-data';
import DocumentDataSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentDataSchema';
import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
import { ZDocumentTitleSchema } from '../document-router/schema';
import { zodFormData } from '../../utils/zod-form-data';
import type { TrpcRouteMeta } from '../trpc';
export const ZCreateEnvelopeItemsRequestSchema = z.object({
export const createEnvelopeItemsMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/item/create-many',
summary: 'Create envelope items',
contentTypes: ['multipart/form-data'],
description: 'Create multiple envelope items for an envelope',
tags: ['Envelope Items'],
},
};
export const ZCreateEnvelopeItemsPayloadSchema = z.object({
envelopeId: z.string(),
items: z
.object({
title: ZDocumentTitleSchema,
documentDataId: z.string(),
})
.array(),
// data: z.object() // Currently not used.
});
export const ZCreateEnvelopeItemsRequestSchema = zodFormData({
payload: zfd.json(ZCreateEnvelopeItemsPayloadSchema),
files: zfd.repeatableOfType(zfd.file()),
});
export const ZCreateEnvelopeItemsResponseSchema = z.object({
createdEnvelopeItems: EnvelopeItemSchema.pick({
data: EnvelopeItemSchema.pick({
id: true,
title: true,
documentDataId: true,
envelopeId: true,
order: true,
})
.extend({
documentData: DocumentDataSchema.pick({
type: true,
id: true,
data: true,
initialData: true,
}),
})
.array(),
}).array(),
});
export type TCreateEnvelopeItemsPayload = z.infer<typeof ZCreateEnvelopeItemsPayloadSchema>;
export type TCreateEnvelopeItemsRequest = z.infer<typeof ZCreateEnvelopeItemsRequestSchema>;
export type TCreateEnvelopeItemsResponse = z.infer<typeof ZCreateEnvelopeItemsResponseSchema>;

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

@ -1,18 +1,25 @@
import { getServerLimits } from '@documenso/ee/server-only/limits/server';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { createEnvelope } from '@documenso/lib/server-only/envelope/create-envelope';
import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
import { insertFormValuesInPdf } from '../../../lib/server-only/pdf/insert-form-values-in-pdf';
import { authenticatedProcedure } from '../trpc';
import {
ZCreateEnvelopeRequestSchema,
ZCreateEnvelopeResponseSchema,
createEnvelopeMeta,
} from './create-envelope.types';
export const createEnvelopeRoute = authenticatedProcedure
.meta(createEnvelopeMeta)
.input(ZCreateEnvelopeRequestSchema)
.output(ZCreateEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId } = ctx;
const { payload, files } = input;
const {
title,
type,
@ -20,12 +27,12 @@ export const createEnvelopeRoute = authenticatedProcedure
visibility,
globalAccessAuth,
globalActionAuth,
formValues,
recipients,
folderId,
items,
meta,
attachments,
} = input;
} = payload;
ctx.logger.info({
input: {
@ -45,13 +52,83 @@ export const createEnvelopeRoute = authenticatedProcedure
});
}
if (items.length > maximumEnvelopeItemCount) {
if (files.length > maximumEnvelopeItemCount) {
throw new AppError('ENVELOPE_ITEM_LIMIT_EXCEEDED', {
message: `You cannot upload more than ${maximumEnvelopeItemCount} envelope items per envelope`,
statusCode: 400,
});
}
if (files.some((file) => !file.type.startsWith('application/pdf'))) {
throw new AppError('INVALID_DOCUMENT_FILE', {
message: 'You cannot upload non-PDF files',
statusCode: 400,
});
}
// For each file, stream to s3 and create the document data.
const envelopeItems = await Promise.all(
files.map(async (file) => {
let pdf = Buffer.from(await file.arrayBuffer());
if (formValues) {
// eslint-disable-next-line require-atomic-updates
pdf = await insertFormValuesInPdf({
pdf,
formValues,
});
}
const { id: documentDataId } = await putNormalizedPdfFileServerSide({
name: file.name,
type: 'application/pdf',
arrayBuffer: async () => Promise.resolve(pdf),
});
return {
title: file.name,
documentDataId,
};
}),
);
const recipientsToCreate = recipients?.map((recipient) => ({
email: recipient.email,
name: recipient.name,
role: recipient.role,
signingOrder: recipient.signingOrder,
accessAuth: recipient.accessAuth,
actionAuth: recipient.actionAuth,
fields: recipient.fields?.map((field) => {
let documentDataId: string | undefined = undefined;
if (typeof field.identifier === 'string') {
documentDataId = envelopeItems.find(
(item) => item.title === field.identifier,
)?.documentDataId;
}
if (typeof field.identifier === 'number') {
documentDataId = envelopeItems.at(field.identifier)?.documentDataId;
}
if (field.identifier === undefined) {
documentDataId = envelopeItems.at(0)?.documentDataId;
}
if (!documentDataId) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'Document data not found',
});
}
return {
...field,
documentDataId,
};
}),
}));
const envelope = await createEnvelope({
userId: user.id,
teamId,
@ -60,16 +137,16 @@ export const createEnvelopeRoute = authenticatedProcedure
type,
title,
externalId,
formValues,
visibility,
globalAccessAuth,
globalActionAuth,
recipients,
recipients: recipientsToCreate,
folderId,
envelopeItems: items,
envelopeItems,
},
attachments,
meta,
normalizePdf: true,
requestMetadata: ctx.metadata,
});

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

@ -1,5 +1,6 @@
import { EnvelopeType } from '@prisma/client';
import { z } from 'zod';
import { zfd } from 'zod-form-data';
import {
ZDocumentAccessAuthTypesSchema,
@ -9,32 +10,35 @@ import { ZDocumentFormValuesSchema } from '@documenso/lib/types/document-form-va
import { ZDocumentMetaCreateSchema } from '@documenso/lib/types/document-meta';
import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
import {
ZFieldHeightSchema,
ZClampedFieldHeightSchema,
ZClampedFieldPositionXSchema,
ZClampedFieldPositionYSchema,
ZClampedFieldWidthSchema,
ZFieldPageNumberSchema,
ZFieldPageXSchema,
ZFieldPageYSchema,
ZFieldWidthSchema,
} from '@documenso/lib/types/field';
import { ZFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
import { ZEnvelopeFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
import { zodFormData } from '../../utils/zod-form-data';
import {
ZDocumentExternalIdSchema,
ZDocumentTitleSchema,
ZDocumentVisibilitySchema,
} from '../document-router/schema';
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',
// summary: 'Create envelope',
// tags: ['Envelope'],
// },
// };
export const createEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/create',
contentTypes: ['multipart/form-data'],
summary: 'Create envelope',
description: 'Create an envelope using form data.',
tags: ['Envelope'],
},
};
export const ZCreateEnvelopeRequestSchema = z.object({
export const ZCreateEnvelopePayloadSchema = z.object({
title: ZDocumentTitleSchema,
type: z.nativeEnum(EnvelopeType),
externalId: ZDocumentExternalIdSchema.optional(),
@ -42,12 +46,6 @@ export const ZCreateEnvelopeRequestSchema = z.object({
globalAccessAuth: z.array(ZDocumentAccessAuthTypesSchema).optional(),
globalActionAuth: z.array(ZDocumentActionAuthTypesSchema).optional(),
formValues: ZDocumentFormValuesSchema.optional(),
items: z
.object({
title: ZDocumentTitleSchema.optional(),
documentDataId: z.string(),
})
.array(),
folderId: z
.string()
.describe(
@ -57,18 +55,19 @@ export const ZCreateEnvelopeRequestSchema = z.object({
recipients: z
.array(
ZCreateRecipientSchema.extend({
fields: ZFieldAndMetaSchema.and(
fields: ZEnvelopeFieldAndMetaSchema.and(
z.object({
documentDataId: z
.string()
identifier: z
.union([z.string(), z.number()])
.describe(
'The ID of the document data to create the field on. If empty, the first document data will be used.',
),
'Either the filename or the index of the file that was uploaded to attach the field to.',
)
.optional(),
page: ZFieldPageNumberSchema,
positionX: ZFieldPageXSchema,
positionY: ZFieldPageYSchema,
width: ZFieldWidthSchema,
height: ZFieldHeightSchema,
positionX: ZClampedFieldPositionXSchema,
positionY: ZClampedFieldPositionYSchema,
width: ZClampedFieldWidthSchema,
height: ZClampedFieldHeightSchema,
}),
)
.array()
@ -88,9 +87,15 @@ export const ZCreateEnvelopeRequestSchema = z.object({
.optional(),
});
export const ZCreateEnvelopeRequestSchema = zodFormData({
payload: zfd.json(ZCreateEnvelopePayloadSchema),
files: zfd.repeatableOfType(zfd.file()),
});
export const ZCreateEnvelopeResponseSchema = z.object({
id: z.string(),
});
export type TCreateEnvelopePayload = z.infer<typeof ZCreateEnvelopePayloadSchema>;
export type TCreateEnvelopeRequest = z.infer<typeof ZCreateEnvelopeRequestSchema>;
export type TCreateEnvelopeResponse = z.infer<typeof ZCreateEnvelopeResponseSchema>;

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

@ -5,13 +5,16 @@ import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-
import { canEnvelopeItemsBeModified } from '@documenso/lib/utils/envelope';
import { prisma } from '@documenso/prisma';
import { ZGenericSuccessResponse } from '../schema';
import { authenticatedProcedure } from '../trpc';
import {
ZDeleteEnvelopeItemRequestSchema,
ZDeleteEnvelopeItemResponseSchema,
deleteEnvelopeItemMeta,
} from './delete-envelope-item.types';
export const deleteEnvelopeItemRoute = authenticatedProcedure
.meta(deleteEnvelopeItemMeta)
.input(ZDeleteEnvelopeItemRequestSchema)
.output(ZDeleteEnvelopeItemResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -98,4 +101,6 @@ export const deleteEnvelopeItemRoute = authenticatedProcedure
},
},
});
return ZGenericSuccessResponse;
});

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

@ -1,11 +1,24 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../schema';
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(),
});
export const ZDeleteEnvelopeItemResponseSchema = z.void();
export const ZDeleteEnvelopeItemResponseSchema = ZSuccessResponseSchema;
export type TDeleteEnvelopeItemRequest = z.infer<typeof ZDeleteEnvelopeItemRequestSchema>;
export type TDeleteEnvelopeItemResponse = z.infer<typeof ZDeleteEnvelopeItemResponseSchema>;

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

@ -1,22 +1,26 @@
import { EnvelopeType } from '@prisma/client';
import { match } from 'ts-pattern';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { deleteDocument } from '@documenso/lib/server-only/document/delete-document';
import { deleteTemplate } from '@documenso/lib/server-only/template/delete-template';
import { prisma } from '@documenso/prisma';
import { ZGenericSuccessResponse } from '../schema';
import { authenticatedProcedure } from '../trpc';
import {
ZDeleteEnvelopeRequestSchema,
ZDeleteEnvelopeResponseSchema,
deleteEnvelopeMeta,
} from './delete-envelope.types';
export const deleteEnvelopeRoute = authenticatedProcedure
// .meta(deleteEnvelopeMeta)
.meta(deleteEnvelopeMeta)
.input(ZDeleteEnvelopeRequestSchema)
.output(ZDeleteEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {
const { teamId } = ctx;
const { envelopeId, envelopeType } = input;
const { envelopeId } = input;
ctx.logger.info({
input: {
@ -24,7 +28,22 @@ export const deleteEnvelopeRoute = authenticatedProcedure
},
});
await match(envelopeType)
const unsafeEnvelope = await prisma.envelope.findUnique({
where: {
id: envelopeId,
},
select: {
type: true,
},
});
if (!unsafeEnvelope) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'Envelope not found',
});
}
await match(unsafeEnvelope.type)
.with(EnvelopeType.DOCUMENT, async () =>
deleteDocument({
userId: ctx.user.id,
@ -47,4 +66,6 @@ export const deleteEnvelopeRoute = authenticatedProcedure
}),
)
.exhaustive();
return ZGenericSuccessResponse;
});

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

@ -1,21 +1,22 @@
import { EnvelopeType } from '@prisma/client';
import { z } from 'zod';
// export const deleteEnvelopeMeta: TrpcRouteMeta = {
// openapi: {
// method: 'POST',
// path: '/envelope/delete',
// summary: 'Delete envelope',
// tags: ['Envelope'],
// },
// };
import { ZSuccessResponseSchema } from '../schema';
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(),
envelopeType: z.nativeEnum(EnvelopeType),
});
export const ZDeleteEnvelopeResponseSchema = z.void();
export const ZDeleteEnvelopeResponseSchema = ZSuccessResponseSchema;
export type TDeleteEnvelopeRequest = z.infer<typeof ZDeleteEnvelopeRequestSchema>;
export type TDeleteEnvelopeResponse = z.infer<typeof ZDeleteEnvelopeResponseSchema>;

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

@ -1,14 +1,16 @@
import { updateDocumentMeta } from '@documenso/lib/server-only/document-meta/upsert-document-meta';
import { sendDocument } from '@documenso/lib/server-only/document/send-document';
import { formatSigningLink } from '@documenso/lib/utils/recipients';
import { authenticatedProcedure } from '../trpc';
import {
ZDistributeEnvelopeRequestSchema,
ZDistributeEnvelopeResponseSchema,
distributeEnvelopeMeta,
} from './distribute-envelope.types';
export const distributeEnvelopeRoute = authenticatedProcedure
// .meta(distributeEnvelopeMeta)
.meta(distributeEnvelopeMeta)
.input(ZDistributeEnvelopeRequestSchema)
.output(ZDistributeEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -43,7 +45,7 @@ export const distributeEnvelopeRoute = authenticatedProcedure
});
}
await sendDocument({
const envelope = await sendDocument({
userId: ctx.user.id,
id: {
type: 'envelopeId',
@ -52,4 +54,18 @@ export const distributeEnvelopeRoute = authenticatedProcedure
teamId,
requestMetadata: ctx.metadata,
});
return {
success: true,
id: envelope.id,
recipients: envelope.recipients.map((recipient) => ({
id: recipient.id,
name: recipient.name,
email: recipient.email,
token: recipient.token,
role: recipient.role,
signingOrder: recipient.signingOrder,
signingUrl: formatSigningLink(recipient.token),
})),
};
});

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

@ -2,15 +2,19 @@ import { z } from 'zod';
import { ZDocumentMetaUpdateSchema } from '@documenso/lib/types/document-meta';
// export const distributeEnvelopeMeta: TrpcRouteMeta = {
// openapi: {
// method: 'POST',
// path: '/envelope/distribute',
// summary: 'Distribute envelope',
// description: 'Send the document out to recipients based on your distribution method',
// tags: ['Envelope'],
// },
// };
import { ZSuccessResponseSchema } from '../schema';
import type { TrpcRouteMeta } from '../trpc';
import { ZRecipientWithSigningUrlSchema } from './schema';
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.'),
@ -28,7 +32,10 @@ export const ZDistributeEnvelopeRequestSchema = z.object({
}).optional(),
});
export const ZDistributeEnvelopeResponseSchema = z.void();
export const ZDistributeEnvelopeResponseSchema = ZSuccessResponseSchema.extend({
id: z.string().describe('The ID of the envelope that was sent.'),
recipients: ZRecipientWithSigningUrlSchema.array(),
});
export type TDistributeEnvelopeRequest = z.infer<typeof ZDistributeEnvelopeRequestSchema>;
export type TDistributeEnvelopeResponse = z.infer<typeof ZDistributeEnvelopeResponseSchema>;

24
packages/trpc/server/envelope-router/download-envelope-item.ts Normal file
View File

@ -0,0 +1,24 @@
import { authenticatedProcedure } from '../trpc';
import {
ZDownloadEnvelopeItemRequestSchema,
ZDownloadEnvelopeItemResponseSchema,
downloadEnvelopeItemMeta,
} from './download-envelope-item.types';
export const downloadEnvelopeItemRoute = authenticatedProcedure
.meta(downloadEnvelopeItemMeta)
.input(ZDownloadEnvelopeItemRequestSchema)
.output(ZDownloadEnvelopeItemResponseSchema)
.query(({ input, ctx }) => {
const { envelopeItemId, version } = input;
ctx.logger.info({
input: {
envelopeItemId,
version,
},
});
// This endpoint is purely for V2 API, which is implemented in the Hono remix server.
throw new Error('NOT_IMPLEMENTED');
});

31
packages/trpc/server/envelope-router/download-envelope-item.types.ts Normal file
View File

@ -0,0 +1,31 @@
import { z } from 'zod';
import type { TrpcRouteMeta } from '../trpc';
export const downloadEnvelopeItemMeta: TrpcRouteMeta = {
openapi: {
method: 'GET',
path: '/envelope/item/{envelopeItemId}/download',
summary: 'Download an envelope item',
description: 'Download an envelope item by its ID',
tags: ['Envelope Items'],
responseHeaders: z.object({
'Content-Type': z.literal('application/pdf'),
}),
},
};
export const ZDownloadEnvelopeItemRequestSchema = z.object({
envelopeItemId: z.string().describe('The ID of the envelope item to download.'),
version: z
.enum(['original', 'signed'])
.describe(
'The version of the envelope item to download. "signed" returns the completed document with signatures, "original" returns the original uploaded document.',
)
.default('signed'),
});
export const ZDownloadEnvelopeItemResponseSchema = z.instanceof(Uint8Array);
export type TDownloadEnvelopeItemRequest = z.infer<typeof ZDownloadEnvelopeItemRequestSchema>;
export type TDownloadEnvelopeItemResponse = z.infer<typeof ZDownloadEnvelopeItemResponseSchema>;

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

@ -4,9 +4,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZDuplicateEnvelopeRequestSchema,
ZDuplicateEnvelopeResponseSchema,
duplicateEnvelopeMeta,
} from './duplicate-envelope.types';
export const duplicateEnvelopeRoute = authenticatedProcedure
.meta(duplicateEnvelopeMeta)
.input(ZDuplicateEnvelopeRequestSchema)
.output(ZDuplicateEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -29,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>;

38
packages/trpc/server/envelope-router/envelope-fields/create-envelope-fields.ts Normal file
View File

@ -0,0 +1,38 @@
import { createEnvelopeFields } from '@documenso/lib/server-only/field/create-envelope-fields';
import { authenticatedProcedure } from '../../trpc';
import {
ZCreateEnvelopeFieldsRequestSchema,
ZCreateEnvelopeFieldsResponseSchema,
createEnvelopeFieldsMeta,
} from './create-envelope-fields.types';
export const createEnvelopeFieldsRoute = authenticatedProcedure
.meta(createEnvelopeFieldsMeta)
.input(ZCreateEnvelopeFieldsRequestSchema)
.output(ZCreateEnvelopeFieldsResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId, metadata } = ctx;
const { envelopeId, data: fields } = input;
ctx.logger.info({
input: {
envelopeId,
},
});
const { fields: data } = await createEnvelopeFields({
userId: user.id,
teamId,
id: {
type: 'envelopeId',
id: envelopeId,
},
fields,
requestMetadata: metadata,
});
return {
data,
};
});

52
packages/trpc/server/envelope-router/envelope-fields/create-envelope-fields.types.ts Normal file
View File

@ -0,0 +1,52 @@
import { z } from 'zod';
import {
ZClampedFieldHeightSchema,
ZClampedFieldPositionXSchema,
ZClampedFieldPositionYSchema,
ZClampedFieldWidthSchema,
ZFieldPageNumberSchema,
ZFieldSchema,
} from '@documenso/lib/types/field';
import { ZEnvelopeFieldAndMetaSchema } from '@documenso/lib/types/field-meta';
import type { TrpcRouteMeta } from '../../trpc';
export const createEnvelopeFieldsMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/field/create-many',
summary: 'Create envelope fields',
description: 'Create multiple fields for an envelope',
tags: ['Envelope Fields'],
},
};
const ZCreateFieldSchema = ZEnvelopeFieldAndMetaSchema.and(
z.object({
recipientId: z.number().describe('The ID of the recipient to create the field for'),
envelopeItemId: z
.string()
.optional()
.describe(
'The ID of the envelope item to put the field on. If not provided, field will be placed on the first item.',
),
page: ZFieldPageNumberSchema,
positionX: ZClampedFieldPositionXSchema,
positionY: ZClampedFieldPositionYSchema,
width: ZClampedFieldWidthSchema,
height: ZClampedFieldHeightSchema,
}),
);
export const ZCreateEnvelopeFieldsRequestSchema = z.object({
envelopeId: z.string(),
data: ZCreateFieldSchema.array(),
});
export const ZCreateEnvelopeFieldsResponseSchema = z.object({
data: z.array(ZFieldSchema),
});
export type TCreateEnvelopeFieldsRequest = z.infer<typeof ZCreateEnvelopeFieldsRequestSchema>;
export type TCreateEnvelopeFieldsResponse = z.infer<typeof ZCreateEnvelopeFieldsResponseSchema>;

121
packages/trpc/server/envelope-router/envelope-fields/delete-envelope-field.ts Normal file
View File

@ -0,0 +1,121 @@
import { EnvelopeType } from '@prisma/client';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { getEnvelopeWhereInput } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
import { DOCUMENT_AUDIT_LOG_TYPE } from '@documenso/lib/types/document-audit-logs';
import { createDocumentAuditLogData } from '@documenso/lib/utils/document-audit-logs';
import { canRecipientFieldsBeModified } from '@documenso/lib/utils/recipients';
import { prisma } from '@documenso/prisma';
import { ZGenericSuccessResponse } from '../../schema';
import { authenticatedProcedure } from '../../trpc';
import {
ZDeleteEnvelopeFieldRequestSchema,
ZDeleteEnvelopeFieldResponseSchema,
deleteEnvelopeFieldMeta,
} from './delete-envelope-field.types';
export const deleteEnvelopeFieldRoute = authenticatedProcedure
.meta(deleteEnvelopeFieldMeta)
.input(ZDeleteEnvelopeFieldRequestSchema)
.output(ZDeleteEnvelopeFieldResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId, metadata } = ctx;
const { fieldId } = input;
ctx.logger.info({
input: {
fieldId,
},
});
const unsafeField = await prisma.field.findUnique({
where: {
id: fieldId,
},
select: {
envelopeId: true,
},
});
if (!unsafeField) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'Field not found',
});
}
const { envelopeWhereInput } = await getEnvelopeWhereInput({
id: {
type: 'envelopeId',
id: unsafeField.envelopeId,
},
type: null,
userId: user.id,
teamId,
});
const envelope = await prisma.envelope.findUnique({
where: envelopeWhereInput,
include: {
recipients: {
include: {
fields: true,
},
},
},
});
const recipientWithFields = envelope?.recipients.find((recipient) =>
recipient.fields.some((field) => field.id === fieldId),
);
const fieldToDelete = recipientWithFields?.fields.find((field) => field.id === fieldId);
if (!envelope || !recipientWithFields || !fieldToDelete) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'Field not found',
});
}
if (envelope.completedAt) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Envelope already complete',
});
}
// Check whether the recipient associated with the field can have new fields created.
if (!canRecipientFieldsBeModified(recipientWithFields, recipientWithFields.fields)) {
throw new AppError(AppErrorCode.INVALID_REQUEST, {
message: 'Recipient has already interacted with the document.',
});
}
await prisma.$transaction(async (tx) => {
const deletedField = await tx.field.delete({
where: {
id: fieldToDelete.id,
envelopeId: envelope.id,
},
});
// Handle field deleted audit log.
if (envelope.type === EnvelopeType.DOCUMENT) {
await tx.documentAuditLog.create({
data: createDocumentAuditLogData({
type: DOCUMENT_AUDIT_LOG_TYPE.FIELD_DELETED,
envelopeId: envelope.id,
metadata,
data: {
fieldId: deletedField.secondaryId,
fieldRecipientEmail: recipientWithFields.email,
fieldRecipientId: deletedField.recipientId,
fieldType: deletedField.type,
},
}),
});
}
return deletedField;
});
return ZGenericSuccessResponse;
});

23
packages/trpc/server/envelope-router/envelope-fields/delete-envelope-field.types.ts Normal file
View File

@ -0,0 +1,23 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../../schema';
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(),
});
export const ZDeleteEnvelopeFieldResponseSchema = ZSuccessResponseSchema;
export type TDeleteEnvelopeFieldRequest = z.infer<typeof ZDeleteEnvelopeFieldRequestSchema>;
export type TDeleteEnvelopeFieldResponse = z.infer<typeof ZDeleteEnvelopeFieldResponseSchema>;

29
packages/trpc/server/envelope-router/envelope-fields/get-envelope-field.ts Normal file
View File

@ -0,0 +1,29 @@
import { getFieldById } from '@documenso/lib/server-only/field/get-field-by-id';
import { authenticatedProcedure } from '../../trpc';
import {
ZGetEnvelopeFieldRequestSchema,
ZGetEnvelopeFieldResponseSchema,
getEnvelopeFieldMeta,
} from './get-envelope-field.types';
export const getEnvelopeFieldRoute = authenticatedProcedure
.meta(getEnvelopeFieldMeta)
.input(ZGetEnvelopeFieldRequestSchema)
.output(ZGetEnvelopeFieldResponseSchema)
.query(async ({ input, ctx }) => {
const { teamId, user } = ctx;
const { fieldId } = input;
ctx.logger.info({
input: {
fieldId,
},
});
return await getFieldById({
userId: user.id,
teamId,
fieldId,
});
});

24
packages/trpc/server/envelope-router/envelope-fields/get-envelope-field.types.ts Normal file
View File

@ -0,0 +1,24 @@
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(),
});
export const ZGetEnvelopeFieldResponseSchema = ZEnvelopeFieldSchema;
export type TGetEnvelopeFieldRequest = z.infer<typeof ZGetEnvelopeFieldRequestSchema>;
export type TGetEnvelopeFieldResponse = z.infer<typeof ZGetEnvelopeFieldResponseSchema>;

39
packages/trpc/server/envelope-router/envelope-fields/update-envelope-fields.ts Normal file
View File

@ -0,0 +1,39 @@
import { updateEnvelopeFields } from '@documenso/lib/server-only/field/update-envelope-fields';
import { authenticatedProcedure } from '../../trpc';
import {
ZUpdateEnvelopeFieldsRequestSchema,
ZUpdateEnvelopeFieldsResponseSchema,
updateEnvelopeFieldsMeta,
} from './update-envelope-fields.types';
export const updateEnvelopeFieldsRoute = authenticatedProcedure
.meta(updateEnvelopeFieldsMeta)
.input(ZUpdateEnvelopeFieldsRequestSchema)
.output(ZUpdateEnvelopeFieldsResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId } = ctx;
const { envelopeId, data: fields } = input;
ctx.logger.info({
input: {
envelopeId,
},
});
const { fields: data } = await updateEnvelopeFields({
userId: user.id,
teamId,
id: {
type: 'envelopeId',
id: envelopeId,
},
type: null,
fields,
requestMetadata: ctx.metadata,
});
return {
data,
};
});

52
packages/trpc/server/envelope-router/envelope-fields/update-envelope-fields.types.ts Normal file
View File

@ -0,0 +1,52 @@
import { z } from 'zod';
import {
ZClampedFieldHeightSchema,
ZClampedFieldPositionXSchema,
ZClampedFieldPositionYSchema,
ZClampedFieldWidthSchema,
ZFieldPageNumberSchema,
ZFieldSchema,
} from '@documenso/lib/types/field';
import { ZEnvelopeFieldAndMetaSchema } 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 = ZEnvelopeFieldAndMetaSchema.and(
z.object({
id: z.number().describe('The ID of the field to update.'),
envelopeItemId: z
.string()
.optional()
.describe(
'The ID of the envelope item to put the field on. If not provided, field will be placed on the first item.',
),
page: ZFieldPageNumberSchema.optional(),
positionX: ZClampedFieldPositionXSchema.optional(),
positionY: ZClampedFieldPositionYSchema.optional(),
width: ZClampedFieldWidthSchema.optional(),
height: ZClampedFieldHeightSchema.optional(),
}),
);
export const ZUpdateEnvelopeFieldsRequestSchema = z.object({
envelopeId: z.string(),
data: ZUpdateFieldSchema.array(),
});
export const ZUpdateEnvelopeFieldsResponseSchema = z.object({
data: z.array(ZFieldSchema),
});
export type TUpdateEnvelopeFieldsRequest = z.infer<typeof ZUpdateEnvelopeFieldsRequestSchema>;
export type TUpdateEnvelopeFieldsResponse = z.infer<typeof ZUpdateEnvelopeFieldsResponseSchema>;

38
packages/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.ts Normal file
View File

@ -0,0 +1,38 @@
import { createEnvelopeRecipients } from '@documenso/lib/server-only/recipient/create-envelope-recipients';
import { authenticatedProcedure } from '../../trpc';
import {
ZCreateEnvelopeRecipientsRequestSchema,
ZCreateEnvelopeRecipientsResponseSchema,
createEnvelopeRecipientsMeta,
} from './create-envelope-recipients.types';
export const createEnvelopeRecipientsRoute = authenticatedProcedure
.meta(createEnvelopeRecipientsMeta)
.input(ZCreateEnvelopeRecipientsRequestSchema)
.output(ZCreateEnvelopeRecipientsResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId, metadata } = ctx;
const { envelopeId, data: recipients } = input;
ctx.logger.info({
input: {
envelopeId,
},
});
const { recipients: data } = await createEnvelopeRecipients({
userId: user.id,
teamId,
id: {
type: 'envelopeId',
id: envelopeId,
},
recipients,
requestMetadata: metadata,
});
return {
data,
};
});

32
packages/trpc/server/envelope-router/envelope-recipients/create-envelope-recipients.types.ts Normal file
View File

@ -0,0 +1,32 @@
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(),
data: ZCreateRecipientSchema.array(),
});
export const ZCreateEnvelopeRecipientsResponseSchema = z.object({
data: ZEnvelopeRecipientLiteSchema.array(),
});
export type TCreateEnvelopeRecipientsRequest = z.infer<
typeof ZCreateEnvelopeRecipientsRequestSchema
>;
export type TCreateEnvelopeRecipientsResponse = z.infer<
typeof ZCreateEnvelopeRecipientsResponseSchema
>;

33
packages/trpc/server/envelope-router/envelope-recipients/delete-envelope-recipient.ts Normal file
View File

@ -0,0 +1,33 @@
import { deleteEnvelopeRecipient } from '@documenso/lib/server-only/recipient/delete-envelope-recipient';
import { ZGenericSuccessResponse } from '../../schema';
import { authenticatedProcedure } from '../../trpc';
import {
ZDeleteEnvelopeRecipientRequestSchema,
ZDeleteEnvelopeRecipientResponseSchema,
deleteEnvelopeRecipientMeta,
} from './delete-envelope-recipient.types';
export const deleteEnvelopeRecipientRoute = authenticatedProcedure
.meta(deleteEnvelopeRecipientMeta)
.input(ZDeleteEnvelopeRecipientRequestSchema)
.output(ZDeleteEnvelopeRecipientResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId, metadata } = ctx;
const { recipientId } = input;
ctx.logger.info({
input: {
recipientId,
},
});
await deleteEnvelopeRecipient({
userId: user.id,
teamId,
recipientId,
requestMetadata: metadata,
});
return ZGenericSuccessResponse;
});

25
packages/trpc/server/envelope-router/envelope-recipients/delete-envelope-recipient.types.ts Normal file
View File

@ -0,0 +1,25 @@
import { z } from 'zod';
import { ZSuccessResponseSchema } from '../../schema';
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(),
});
export const ZDeleteEnvelopeRecipientResponseSchema = ZSuccessResponseSchema;
export type TDeleteEnvelopeRecipientRequest = z.infer<typeof ZDeleteEnvelopeRecipientRequestSchema>;
export type TDeleteEnvelopeRecipientResponse = z.infer<
typeof ZDeleteEnvelopeRecipientResponseSchema
>;

45
packages/trpc/server/envelope-router/envelope-recipients/get-envelope-recipient.ts Normal file
View File

@ -0,0 +1,45 @@
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { buildTeamWhereQuery } from '@documenso/lib/utils/teams';
import { prisma } from '@documenso/prisma';
import { authenticatedProcedure } from '../../trpc';
import {
ZGetEnvelopeRecipientRequestSchema,
ZGetEnvelopeRecipientResponseSchema,
getEnvelopeRecipientMeta,
} from './get-envelope-recipient.types';
export const getEnvelopeRecipientRoute = authenticatedProcedure
.meta(getEnvelopeRecipientMeta)
.input(ZGetEnvelopeRecipientRequestSchema)
.output(ZGetEnvelopeRecipientResponseSchema)
.query(async ({ input, ctx }) => {
const { teamId, user } = ctx;
const { recipientId } = input;
ctx.logger.info({
input: {
recipientId,
},
});
const recipient = await prisma.recipient.findFirst({
where: {
id: recipientId,
envelope: {
team: buildTeamWhereQuery({ teamId, userId: user.id }),
},
},
include: {
fields: true,
},
});
if (!recipient) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'Recipient not found',
});
}
return recipient;
});

24
packages/trpc/server/envelope-router/envelope-recipients/get-envelope-recipient.types.ts Normal file
View File

@ -0,0 +1,24 @@
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(),
});
export const ZGetEnvelopeRecipientResponseSchema = ZEnvelopeRecipientSchema;
export type TGetEnvelopeRecipientRequest = z.infer<typeof ZGetEnvelopeRecipientRequestSchema>;
export type TGetEnvelopeRecipientResponse = z.infer<typeof ZGetEnvelopeRecipientResponseSchema>;

38
packages/trpc/server/envelope-router/envelope-recipients/update-envelope-recipients.ts Normal file
View File

@ -0,0 +1,38 @@
import { updateEnvelopeRecipients } from '@documenso/lib/server-only/recipient/update-envelope-recipients';
import { authenticatedProcedure } from '../../trpc';
import {
ZUpdateEnvelopeRecipientsRequestSchema,
ZUpdateEnvelopeRecipientsResponseSchema,
updateEnvelopeRecipientsMeta,
} from './update-envelope-recipients.types';
export const updateEnvelopeRecipientsRoute = authenticatedProcedure
.meta(updateEnvelopeRecipientsMeta)
.input(ZUpdateEnvelopeRecipientsRequestSchema)
.output(ZUpdateEnvelopeRecipientsResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId } = ctx;
const { envelopeId, data: recipients } = input;
ctx.logger.info({
input: {
envelopeId,
},
});
const { recipients: data } = await updateEnvelopeRecipients({
userId: user.id,
teamId,
id: {
type: 'envelopeId',
id: envelopeId,
},
recipients,
requestMetadata: ctx.metadata,
});
return {
data,
};
});

32
packages/trpc/server/envelope-router/envelope-recipients/update-envelope-recipients.types.ts Normal file
View File

@ -0,0 +1,32 @@
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(),
data: ZUpdateRecipientSchema.array(),
});
export const ZUpdateEnvelopeRecipientsResponseSchema = z.object({
data: ZRecipientLiteSchema.array(),
});
export type TUpdateEnvelopeRecipientsRequest = z.infer<
typeof ZUpdateEnvelopeRecipientsRequestSchema
>;
export type TUpdateEnvelopeRecipientsResponse = z.infer<
typeof ZUpdateEnvelopeRecipientsResponseSchema
>;

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 ({

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

@ -1,6 +1,5 @@
import { z } from 'zod';
import DocumentDataSchema from '@documenso/prisma/generated/zod/modelSchema/DocumentDataSchema';
import EnvelopeItemSchema from '@documenso/prisma/generated/zod/modelSchema/EnvelopeItemSchema';
export const ZGetEnvelopeItemsByTokenRequestSchema = z.object({
@ -17,18 +16,10 @@ export const ZGetEnvelopeItemsByTokenRequestSchema = z.object({
});
export const ZGetEnvelopeItemsByTokenResponseSchema = z.object({
envelopeItems: EnvelopeItemSchema.pick({
data: EnvelopeItemSchema.pick({
id: true,
envelopeId: true,
title: true,
order: true,
})
.extend({
documentData: DocumentDataSchema.pick({
type: true,
id: true,
data: true,
initialData: true,
}),
})
.array(),
}).array(),
});

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,

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

@ -1,10 +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(getEnvelopeMeta)
.meta(getEnvelopeMeta)
.input(ZGetEnvelopeRequestSchema)
.output(ZGetEnvelopeResponseSchema)
.query(async ({ input, ctx }) => {

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

@ -2,15 +2,17 @@ import { z } from 'zod';
import { ZEnvelopeSchema } from '@documenso/lib/types/envelope';
// export const getEnvelopeMeta: TrpcRouteMeta = {
// openapi: {
// method: 'GET',
// path: '/envelope/{envelopeId}',
// summary: 'Get envelope',
// description: 'Returns a envelope given an ID',
// tags: ['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(),

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

@ -1,13 +1,15 @@
import { resendDocument } from '@documenso/lib/server-only/document/resend-document';
import { formatSigningLink } from '@documenso/lib/utils/recipients';
import { authenticatedProcedure } from '../trpc';
import {
ZRedistributeEnvelopeRequestSchema,
ZRedistributeEnvelopeResponseSchema,
redistributeEnvelopeMeta,
} from './redistribute-envelope.types';
export const redistributeEnvelopeRoute = authenticatedProcedure
// .meta(redistributeEnvelopeMeta)
.meta(redistributeEnvelopeMeta)
.input(ZRedistributeEnvelopeRequestSchema)
.output(ZRedistributeEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -21,7 +23,7 @@ export const redistributeEnvelopeRoute = authenticatedProcedure
},
});
await resendDocument({
const envelope = await resendDocument({
userId: ctx.user.id,
teamId,
id: {
@ -31,4 +33,18 @@ export const redistributeEnvelopeRoute = authenticatedProcedure
recipients,
requestMetadata: ctx.metadata,
});
return {
success: true,
id: envelope.id,
recipients: envelope.recipients.map((recipient) => ({
id: recipient.id,
name: recipient.name,
email: recipient.email,
token: recipient.token,
role: recipient.role,
signingOrder: recipient.signingOrder,
signingUrl: formatSigningLink(recipient.token),
})),
};
});

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

@ -1,15 +1,19 @@
import { z } from 'zod';
// export const redistributeEnvelopeMeta: TrpcRouteMeta = {
// openapi: {
// method: 'POST',
// path: '/envelope/redistribute',
// summary: 'Redistribute document',
// description:
// 'Redistribute the document to the provided recipients who have not actioned the document. Will use the distribution method set in the document',
// tags: ['Envelope'],
// },
// };
import { ZSuccessResponseSchema } from '../schema';
import type { TrpcRouteMeta } from '../trpc';
import { ZRecipientWithSigningUrlSchema } from './schema';
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(),
@ -19,7 +23,10 @@ export const ZRedistributeEnvelopeRequestSchema = z.object({
.describe('The IDs of the recipients to redistribute the envelope to.'),
});
export const ZRedistributeEnvelopeResponseSchema = z.void();
export const ZRedistributeEnvelopeResponseSchema = ZSuccessResponseSchema.extend({
id: z.string().describe('The ID of the envelope that was redistributed.'),
recipients: ZRecipientWithSigningUrlSchema.array(),
});
export type TRedistributeEnvelopeRequest = z.infer<typeof ZRedistributeEnvelopeRequestSchema>;
export type TRedistributeEnvelopeResponse = z.infer<typeof ZRedistributeEnvelopeResponseSchema>;

71
packages/trpc/server/envelope-router/router.ts
View File

@ -8,7 +8,16 @@ import { createEnvelopeItemsRoute } from './create-envelope-items';
import { deleteEnvelopeRoute } from './delete-envelope';
import { deleteEnvelopeItemRoute } from './delete-envelope-item';
import { distributeEnvelopeRoute } from './distribute-envelope';
import { downloadEnvelopeItemRoute } from './download-envelope-item';
import { duplicateEnvelopeRoute } from './duplicate-envelope';
import { createEnvelopeFieldsRoute } from './envelope-fields/create-envelope-fields';
import { deleteEnvelopeFieldRoute } from './envelope-fields/delete-envelope-field';
import { getEnvelopeFieldRoute } from './envelope-fields/get-envelope-field';
import { updateEnvelopeFieldsRoute } from './envelope-fields/update-envelope-fields';
import { createEnvelopeRecipientsRoute } from './envelope-recipients/create-envelope-recipients';
import { deleteEnvelopeRecipientRoute } from './envelope-recipients/delete-envelope-recipient';
import { getEnvelopeRecipientRoute } from './envelope-recipients/get-envelope-recipient';
import { updateEnvelopeRecipientsRoute } from './envelope-recipients/update-envelope-recipients';
import { getEnvelopeRoute } from './get-envelope';
import { getEnvelopeItemsRoute } from './get-envelope-items';
import { getEnvelopeItemsByTokenRoute } from './get-envelope-items-by-token';
@ -16,37 +25,53 @@ import { redistributeEnvelopeRoute } from './redistribute-envelope';
import { setEnvelopeFieldsRoute } from './set-envelope-fields';
import { setEnvelopeRecipientsRoute } from './set-envelope-recipients';
import { signEnvelopeFieldRoute } from './sign-envelope-field';
import { signingStatusEnvelopeRoute } from './signing-status-envelope';
import { updateEnvelopeRoute } from './update-envelope';
import { updateEnvelopeItemsRoute } from './update-envelope-items';
import { useEnvelopeRoute } from './use-envelope';
/**
* Note: The order of the routes is important for public API routes.
*
* Example: GET /envelope/attachment must appear before GET /envelope/:id
*/
export const envelopeRouter = router({
get: getEnvelopeRoute,
create: createEnvelopeRoute,
update: updateEnvelopeRoute,
delete: deleteEnvelopeRoute,
duplicate: duplicateEnvelopeRoute,
distribute: distributeEnvelopeRoute,
redistribute: redistributeEnvelopeRoute,
// share: shareEnvelopeRoute,
item: {
getMany: getEnvelopeItemsRoute,
getManyByToken: getEnvelopeItemsByTokenRoute,
createMany: createEnvelopeItemsRoute,
updateMany: updateEnvelopeItemsRoute,
delete: deleteEnvelopeItemRoute,
},
recipient: {
set: setEnvelopeRecipientsRoute,
},
field: {
set: setEnvelopeFieldsRoute,
sign: signEnvelopeFieldRoute,
},
attachment: {
find: findAttachmentsRoute,
create: createAttachmentRoute,
update: updateAttachmentRoute,
delete: deleteAttachmentRoute,
},
item: {
getMany: getEnvelopeItemsRoute,
getManyByToken: getEnvelopeItemsByTokenRoute,
createMany: createEnvelopeItemsRoute,
updateMany: updateEnvelopeItemsRoute,
delete: deleteEnvelopeItemRoute,
download: downloadEnvelopeItemRoute,
},
recipient: {
get: getEnvelopeRecipientRoute,
createMany: createEnvelopeRecipientsRoute,
updateMany: updateEnvelopeRecipientsRoute,
delete: deleteEnvelopeRecipientRoute,
set: setEnvelopeRecipientsRoute,
},
field: {
get: getEnvelopeFieldRoute,
createMany: createEnvelopeFieldsRoute,
updateMany: updateEnvelopeFieldsRoute,
delete: deleteEnvelopeFieldRoute,
set: setEnvelopeFieldsRoute,
sign: signEnvelopeFieldRoute,
},
get: getEnvelopeRoute,
create: createEnvelopeRoute,
use: useEnvelopeRoute,
update: updateEnvelopeRoute,
delete: deleteEnvelopeRoute,
duplicate: duplicateEnvelopeRoute,
distribute: distributeEnvelopeRoute,
redistribute: redistributeEnvelopeRoute,
signingStatus: signingStatusEnvelopeRoute,
});

16
packages/trpc/server/envelope-router/schema.ts Normal file
View File

@ -0,0 +1,16 @@
import { z } from 'zod';
import RecipientSchema from '@documenso/prisma/generated/zod/modelSchema/RecipientSchema';
// Common schemas between envelope routes.
export const ZRecipientWithSigningUrlSchema = RecipientSchema.pick({
id: true,
name: true,
email: true,
token: true,
role: true,
signingOrder: true,
}).extend({
signingUrl: z.string().describe('The URL which the recipient uses to sign the document.'),
});

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,
})),

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

@ -1,12 +1,19 @@
import { EnvelopeType, FieldType } from '@prisma/client';
import { z } from 'zod';
import {
ZClampedFieldHeightSchema,
ZClampedFieldPositionXSchema,
ZClampedFieldPositionYSchema,
ZClampedFieldWidthSchema,
} from '@documenso/lib/types/field';
import { ZFieldMetaSchema } from '@documenso/lib/types/field-meta';
export const ZSetEnvelopeFieldsRequestSchema = z.object({
envelopeId: z.string(),
envelopeType: z.nativeEnum(EnvelopeType),
fields: z.array(
// Todo: Envelopes - Use strict schema for types + field meta.
z.object({
id: z
.number()
@ -20,34 +27,17 @@ export const ZSetEnvelopeFieldsRequestSchema = z.object({
.number()
.min(1)
.describe('The page number of the field on the envelope. Starts from 1.'),
// Todo: Envelopes - Extract these 0-100 schemas with better descriptions.
positionX: z
.number()
.min(0)
.max(100)
.describe('The percentage based X position of the field on the envelope.'),
positionY: z
.number()
.min(0)
.max(100)
.describe('The percentage based Y position of the field on the envelope.'),
width: z
.number()
.min(0)
.max(100)
.describe('The percentage based width of the field on the envelope.'),
height: z
.number()
.min(0)
.max(100)
.describe('The percentage based height of the field on the envelope.'),
fieldMeta: ZFieldMetaSchema, // Todo: Envelopes - Use a more strict form?
positionX: ZClampedFieldPositionXSchema,
positionY: ZClampedFieldPositionYSchema,
width: ZClampedFieldWidthSchema,
height: ZClampedFieldHeightSchema,
fieldMeta: ZFieldMetaSchema,
}),
),
});
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(),

43
packages/trpc/server/envelope-router/sign-envelope-field.ts
View File

@ -133,6 +133,49 @@ export const signEnvelopeFieldRoute = procedure
const insertionValues = extractFieldInsertionValues({ fieldValue, field, documentMeta });
// Early return for uninserting fields.
if (!insertionValues.inserted) {
return await prisma.$transaction(async (tx) => {
const updatedField = await tx.field.update({
where: {
id: field.id,
},
data: {
customText: '',
inserted: false,
},
});
await tx.signature.deleteMany({
where: {
fieldId: field.id,
},
});
if (recipient.role !== RecipientRole.ASSISTANT) {
await tx.documentAuditLog.create({
data: createDocumentAuditLogData({
type: DOCUMENT_AUDIT_LOG_TYPE.DOCUMENT_FIELD_UNINSERTED,
envelopeId: envelope.id,
user: {
name: recipient.name,
email: recipient.email,
},
requestMetadata: metadata.requestMetadata,
data: {
field: field.type,
fieldId: field.secondaryId,
},
}),
});
}
return {
signedField: updatedField,
};
});
}
const derivedRecipientActionAuth = await validateFieldAuth({
documentAuthOptions: envelope.authOptions,
recipient,

2
packages/trpc/server/envelope-router/sign-envelope-field.types.ts
View File

@ -16,7 +16,7 @@ export const ZSignEnvelopeFieldValue = z.discriminatedUnion('type', [
}),
z.object({
type: z.literal(FieldType.NUMBER),
value: z.number().nullable(),
value: z.string().nullable(),
}),
z.object({
type: z.literal(FieldType.EMAIL),

82
packages/trpc/server/envelope-router/signing-status-envelope.ts Normal file
View File

@ -0,0 +1,82 @@
import { DocumentStatus, EnvelopeType, RecipientRole, SigningStatus } from '@prisma/client';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { prisma } from '@documenso/prisma';
import { maybeAuthenticatedProcedure } from '../trpc';
import {
ZSigningStatusEnvelopeRequestSchema,
ZSigningStatusEnvelopeResponseSchema,
} from './signing-status-envelope.types';
// Internal route - not intended for public API usage
export const signingStatusEnvelopeRoute = maybeAuthenticatedProcedure
.input(ZSigningStatusEnvelopeRequestSchema)
.output(ZSigningStatusEnvelopeResponseSchema)
.query(async ({ input, ctx }) => {
const { token } = input;
ctx.logger.info({
input: {
token,
},
});
const envelope = await prisma.envelope.findFirst({
where: {
type: EnvelopeType.DOCUMENT,
recipients: {
some: {
token,
},
},
},
include: {
recipients: {
select: {
id: true,
name: true,
email: true,
signingStatus: true,
role: true,
},
},
},
});
if (!envelope) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: 'Envelope not found',
});
}
// Check if envelope is rejected
if (envelope.status === DocumentStatus.REJECTED) {
return {
status: 'REJECTED',
};
}
if (envelope.status === DocumentStatus.COMPLETED) {
return {
status: 'COMPLETED',
};
}
const isComplete =
envelope.recipients.some((recipient) => recipient.signingStatus === SigningStatus.REJECTED) ||
envelope.recipients.every(
(recipient) =>
recipient.role === RecipientRole.CC || recipient.signingStatus === SigningStatus.SIGNED,
);
if (isComplete) {
return {
status: 'PROCESSING',
};
}
return {
status: 'PENDING',
};
});

14
packages/trpc/server/envelope-router/signing-status-envelope.types.ts Normal file
View File

@ -0,0 +1,14 @@
import { z } from 'zod';
export const EnvelopeSigningStatus = z.enum(['PENDING', 'PROCESSING', 'COMPLETED', 'REJECTED']);
export const ZSigningStatusEnvelopeRequestSchema = z.object({
token: z.string().describe('The recipient token to check the signing status for'),
});
export const ZSigningStatusEnvelopeResponseSchema = z.object({
status: EnvelopeSigningStatus.describe('The current signing status of the envelope'),
});
export type TSigningStatusEnvelopeRequest = z.infer<typeof ZSigningStatusEnvelopeRequestSchema>;
export type TSigningStatusEnvelopeResponse = z.infer<typeof ZSigningStatusEnvelopeResponseSchema>;

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

@ -7,9 +7,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZUpdateEnvelopeItemsRequestSchema,
ZUpdateEnvelopeItemsResponseSchema,
updateEnvelopeItemsMeta,
} from './update-envelope-items.types';
export const updateEnvelopeItemsRoute = authenticatedProcedure
.meta(updateEnvelopeItemsMeta)
.input(ZUpdateEnvelopeItemsRequestSchema)
.output(ZUpdateEnvelopeItemsResponseSchema)
.mutation(async ({ input, ctx }) => {
@ -93,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,

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

@ -4,10 +4,11 @@ import { authenticatedProcedure } from '../trpc';
import {
ZUpdateEnvelopeRequestSchema,
ZUpdateEnvelopeResponseSchema,
updateEnvelopeMeta,
} from './update-envelope.types';
export const updateEnvelopeRoute = authenticatedProcedure
// .meta(updateEnvelopeTrpcMeta)
.meta(updateEnvelopeMeta)
.input(ZUpdateEnvelopeRequestSchema)
.output(ZUpdateEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {

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

@ -1,5 +1,3 @@
import { EnvelopeType } from '@prisma/client';
// import type { OpenApiMeta } from 'trpc-to-openapi';
import { z } from 'zod';
import {
@ -14,19 +12,19 @@ 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 updateEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/update',
summary: 'Update envelope',
tags: ['Envelope'],
},
};
export const ZUpdateEnvelopeRequestSchema = z.object({
envelopeId: z.string(),
envelopeType: z.nativeEnum(EnvelopeType),
data: z
.object({
title: ZDocumentTitleSchema.optional(),

180
packages/trpc/server/envelope-router/use-envelope.ts Normal file
View File

@ -0,0 +1,180 @@
import { EnvelopeType } from '@prisma/client';
import { getServerLimits } from '@documenso/ee/server-only/limits/server';
import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
import { sendDocument } from '@documenso/lib/server-only/document/send-document';
import { getEnvelopeById } from '@documenso/lib/server-only/envelope/get-envelope-by-id';
import { createDocumentFromTemplate } from '@documenso/lib/server-only/template/create-document-from-template';
import { putNormalizedPdfFileServerSide } from '@documenso/lib/universal/upload/put-file.server';
import { formatSigningLink } from '@documenso/lib/utils/recipients';
import { authenticatedProcedure } from '../trpc';
import {
ZUseEnvelopeRequestSchema,
ZUseEnvelopeResponseSchema,
useEnvelopeMeta,
} from './use-envelope.types';
export const useEnvelopeRoute = authenticatedProcedure
.meta(useEnvelopeMeta)
.input(ZUseEnvelopeRequestSchema)
.output(ZUseEnvelopeResponseSchema)
.mutation(async ({ input, ctx }) => {
const { user, teamId } = ctx;
const { payload, files = [] } = input;
const {
envelopeId,
externalId,
recipients = [],
distributeDocument,
customDocumentData = [],
folderId,
prefillFields,
override,
attachments,
} = payload;
ctx.logger.info({
input: {
envelopeId,
folderId,
},
});
const limits = await getServerLimits({ userId: user.id, teamId });
if (limits.remaining.documents === 0) {
throw new AppError(AppErrorCode.LIMIT_EXCEEDED, {
message: 'You have reached your document limit.',
});
}
// Verify the template exists and get envelope items
const envelope = await getEnvelopeById({
id: {
type: 'envelopeId',
id: envelopeId,
},
type: EnvelopeType.TEMPLATE,
userId: user.id,
teamId,
});
if (files.length > envelope.envelopeItems.length) {
throw new AppError(AppErrorCode.INVALID_BODY, {
message: `You cannot upload more than ${envelope.envelopeItems.length} envelope items per envelope`,
});
}
const filesToUpload = files.filter(
(file, index) =>
payload.customDocumentData &&
payload.customDocumentData.some(
(mapping) => mapping.identifier === file.name || mapping.identifier === index,
),
);
// Process uploaded files and create document data for them
const uploadedFiles = await Promise.all(
filesToUpload.map(async (file) => {
const { id: documentDataId } = await putNormalizedPdfFileServerSide(file);
return {
name: file.name,
documentDataId,
};
}),
);
// Map custom document data using identifiers
const customDocumentDataMapped = customDocumentData?.map((mapping) => {
let documentDataId: string | undefined;
// Find the uploaded file by identifier
if (typeof mapping.identifier === 'string') {
documentDataId = uploadedFiles.find(
(file) => file.name === mapping.identifier,
)?.documentDataId;
}
if (typeof mapping.identifier === 'number') {
documentDataId = uploadedFiles.at(mapping.identifier)?.documentDataId;
}
if (mapping.identifier === undefined) {
documentDataId = uploadedFiles.at(0)?.documentDataId;
}
if (!documentDataId) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: `File with identifier "${mapping.identifier}" not found in uploaded files`,
});
}
// Verify that the envelopeItemId exists in the template
const envelopeItem = envelope.envelopeItems.find(
(item) => item.id === mapping.envelopeItemId,
);
if (!envelopeItem) {
throw new AppError(AppErrorCode.NOT_FOUND, {
message: `Envelope item with ID "${mapping.envelopeItemId}" not found in template`,
});
}
return {
documentDataId,
envelopeItemId: mapping.envelopeItemId,
};
});
// Create document from template
const createdEnvelope = await createDocumentFromTemplate({
id: {
type: 'envelopeId',
id: envelopeId,
},
externalId,
teamId,
userId: user.id,
recipients,
customDocumentData: customDocumentDataMapped,
requestMetadata: ctx.metadata,
folderId,
prefillFields,
override,
attachments,
});
// Distribute document if requested
if (distributeDocument) {
await sendDocument({
id: {
type: 'envelopeId',
id: createdEnvelope.id,
},
userId: user.id,
teamId,
requestMetadata: ctx.metadata,
}).catch((err) => {
console.error(err);
throw new AppError('DOCUMENT_SEND_FAILED');
});
}
return {
id: createdEnvelope.id,
recipients: createdEnvelope.recipients.map((recipient) => ({
id: recipient.id,
name: recipient.name,
email: recipient.email,
token: recipient.token,
role: recipient.role,
signingOrder: recipient.signingOrder,
signingUrl: formatSigningLink(recipient.token),
})),
};
});

124
packages/trpc/server/envelope-router/use-envelope.types.ts Normal file
View File

@ -0,0 +1,124 @@
import { z } from 'zod';
import { zfd } from 'zod-form-data';
import { ZDocumentEmailSettingsSchema } from '@documenso/lib/types/document-email';
import {
ZDocumentMetaDateFormatSchema,
ZDocumentMetaDistributionMethodSchema,
ZDocumentMetaDrawSignatureEnabledSchema,
ZDocumentMetaLanguageSchema,
ZDocumentMetaMessageSchema,
ZDocumentMetaRedirectUrlSchema,
ZDocumentMetaSubjectSchema,
ZDocumentMetaTimezoneSchema,
ZDocumentMetaTypedSignatureEnabledSchema,
ZDocumentMetaUploadSignatureEnabledSchema,
} from '@documenso/lib/types/document-meta';
import { ZEnvelopeAttachmentTypeSchema } from '@documenso/lib/types/envelope-attachment';
import { ZFieldMetaPrefillFieldsSchema } from '@documenso/lib/types/field-meta';
import { zodFormData } from '../../utils/zod-form-data';
import type { TrpcRouteMeta } from '../trpc';
import { ZRecipientWithSigningUrlSchema } from './schema';
export const useEnvelopeMeta: TrpcRouteMeta = {
openapi: {
method: 'POST',
path: '/envelope/use',
contentTypes: ['multipart/form-data'],
summary: 'Use envelope',
description:
'Create a document envelope from a template envelope. Upload custom files to replace the template PDFs and map them to specific envelope items using identifiers.',
tags: ['Envelope'],
},
};
export const ZUseEnvelopePayloadSchema = z.object({
envelopeId: z.string().describe('The ID of the template envelope to use.'),
externalId: z.string().optional().describe('External ID for the created document.'),
recipients: z
.array(
z.object({
id: z.number().describe('The ID of the recipient in the template.'),
email: z.string().email().max(254),
name: z.string().max(255).optional(),
signingOrder: z.number().optional(),
}),
)
.describe('The information of the recipients to create the document with.')
.optional(),
distributeDocument: z
.boolean()
.describe('Whether to create the document as pending and distribute it to recipients.')
.optional(),
customDocumentData: z
.array(
z.object({
identifier: z
.union([z.string(), z.number()])
.describe(
'Either the filename or the index of the file that was uploaded. This maps to which envelope item in the template should use this file.',
),
envelopeItemId: z
.string()
.describe('The envelope item ID from the template to replace with the uploaded file.'),
}),
)
.describe(
'Map uploaded files to specific envelope items in the template. If not provided, files will be ignored.',
)
.optional(),
folderId: z
.string()
.describe(
'The ID of the folder to create the document in. If not provided, the document will be created in the root folder.',
)
.optional(),
prefillFields: z
.array(ZFieldMetaPrefillFieldsSchema)
.describe(
'The fields to prefill on the document before sending it out. Useful when you want to create a document from an existing template and pre-fill the fields with specific values.',
)
.optional(),
override: z
.object({
title: z.string().min(1).max(255).optional(),
subject: ZDocumentMetaSubjectSchema.optional(),
message: ZDocumentMetaMessageSchema.optional(),
timezone: ZDocumentMetaTimezoneSchema.optional(),
dateFormat: ZDocumentMetaDateFormatSchema.optional(),
redirectUrl: ZDocumentMetaRedirectUrlSchema.optional(),
distributionMethod: ZDocumentMetaDistributionMethodSchema.optional(),
emailSettings: ZDocumentEmailSettingsSchema.optional(),
language: ZDocumentMetaLanguageSchema.optional(),
typedSignatureEnabled: ZDocumentMetaTypedSignatureEnabledSchema.optional(),
uploadSignatureEnabled: ZDocumentMetaUploadSignatureEnabledSchema.optional(),
drawSignatureEnabled: ZDocumentMetaDrawSignatureEnabledSchema.optional(),
allowDictateNextSigner: z.boolean().optional(),
})
.describe('Override values from the template for the created document.')
.optional(),
attachments: z
.array(
z.object({
label: z.string().min(1, 'Label is required'),
data: z.string().url('Must be a valid URL'),
type: ZEnvelopeAttachmentTypeSchema.optional().default('link'),
}),
)
.optional(),
});
export const ZUseEnvelopeRequestSchema = zodFormData({
payload: zfd.json(ZUseEnvelopePayloadSchema),
files: zfd.repeatableOfType(zfd.file()).optional(),
});
export const ZUseEnvelopeResponseSchema = z.object({
id: z.string().describe('The ID of the created envelope.'),
recipients: ZRecipientWithSigningUrlSchema.array(),
});
export type TUseEnvelopePayload = z.infer<typeof ZUseEnvelopePayloadSchema>;
export type TUseEnvelopeRequest = z.infer<typeof ZUseEnvelopeRequestSchema>;
export type TUseEnvelopeResponse = z.infer<typeof ZUseEnvelopeResponseSchema>;

Some files were not shown because too many files have changed in this diff Show More