feat: add direct templates links (#1165)

## Description

Direct templates links is a feature that provides template owners the
ability to allow users to create documents based of their templates.

## General outline

This works by allowing the template owner to configure a "direct
recipient" in the template.

When a user opens the direct link to the template, it will create a flow
where they sign the fields configured by the template owner for the
direct recipient. After these fields are signed the following will
occur:

- A document will be created where the owner is the template owner
- The direct recipient fields will be signed
- The document will be sent to any other recipients configured in the
template
- If there are none the document will be immediately completed

## Notes

There's a custom prisma migration to migrate all documents to have
'DOCUMENT' as the source, then sets the column to required.

---------

Co-authored-by: Lucas Smith <me@lucasjamessmith.me>

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

@@ -1,24 +1,32 @@
 import { TRPCError } from '@trpc/server';
 
 import { getServerLimits } from '@documenso/ee/server-only/limits/server';
-import { AppError } from '@documenso/lib/errors/app-error';
+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';
 import { sendDocument } from '@documenso/lib/server-only/document/send-document';
+import { createDocumentFromDirectTemplate } from '@documenso/lib/server-only/template/create-document-from-direct-template';
 import { createDocumentFromTemplate } from '@documenso/lib/server-only/template/create-document-from-template';
 import { createTemplate } from '@documenso/lib/server-only/template/create-template';
+import { createTemplateDirectLink } from '@documenso/lib/server-only/template/create-template-direct-link';
 import { deleteTemplate } from '@documenso/lib/server-only/template/delete-template';
+import { deleteTemplateDirectLink } from '@documenso/lib/server-only/template/delete-template-direct-link';
 import { duplicateTemplate } from '@documenso/lib/server-only/template/duplicate-template';
 import { getTemplateWithDetailsById } from '@documenso/lib/server-only/template/get-template-with-details-by-id';
+import { toggleTemplateDirectLink } from '@documenso/lib/server-only/template/toggle-template-direct-link';
 import { updateTemplateSettings } from '@documenso/lib/server-only/template/update-template-settings';
 import { extractNextApiRequestMetadata } from '@documenso/lib/universal/extract-request-metadata';
 import type { Document } from '@documenso/prisma/client';
 
-import { authenticatedProcedure, router } from '../trpc';
+import { authenticatedProcedure, maybeAuthenticatedProcedure, router } from '../trpc';
 import {
+  ZCreateDocumentFromDirectTemplateMutationSchema,
   ZCreateDocumentFromTemplateMutationSchema,
+  ZCreateTemplateDirectLinkMutationSchema,
   ZCreateTemplateMutationSchema,
+  ZDeleteTemplateDirectLinkMutationSchema,
   ZDeleteTemplateMutationSchema,
   ZDuplicateTemplateMutationSchema,
   ZGetTemplateWithDetailsByIdQuerySchema,
+  ZToggleTemplateDirectLinkMutationSchema,
   ZUpdateTemplateSettingsMutationSchema,
 } from './schema';
 
@@ -45,6 +53,36 @@ export const templateRouter = router({
       }
     }),
 
+  createDocumentFromDirectTemplate: maybeAuthenticatedProcedure
+    .input(ZCreateDocumentFromDirectTemplateMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { directRecipientEmail, directTemplateToken, signedFieldValues, templateUpdatedAt } =
+          input;
+
+        const requestMetadata = extractNextApiRequestMetadata(ctx.req);
+
+        return await createDocumentFromDirectTemplate({
+          directRecipientEmail,
+          directTemplateToken,
+          signedFieldValues,
+          templateUpdatedAt,
+          user: ctx.user
+            ? {
+                id: ctx.user.id,
+                name: ctx.user.name || undefined,
+                email: ctx.user.email,
+              }
+            : undefined,
+          requestMetadata,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
   createDocumentFromTemplate: authenticatedProcedure
     .input(ZCreateDocumentFromTemplateMutationSchema)
     .mutation(async ({ input, ctx }) => {
@@ -175,4 +213,64 @@ export const templateRouter = router({
         });
       }
     }),
+
+  createTemplateDirectLink: authenticatedProcedure
+    .input(ZCreateTemplateDirectLinkMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { templateId, directRecipientId } = input;
+
+        const userId = ctx.user.id;
+
+        const limits = await getServerLimits({ email: ctx.user.email });
+
+        if (limits.remaining.directTemplates === 0) {
+          throw new AppError(
+            AppErrorCode.LIMIT_EXCEEDED,
+            'You have reached your direct templates limit.',
+          );
+        }
+
+        return await createTemplateDirectLink({ userId, templateId, directRecipientId });
+      } catch (err) {
+        console.error(err);
+
+        const error = AppError.parseError(err);
+        throw AppError.parseErrorToTRPCError(error);
+      }
+    }),
+
+  deleteTemplateDirectLink: authenticatedProcedure
+    .input(ZDeleteTemplateDirectLinkMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { templateId } = input;
+
+        const userId = ctx.user.id;
+
+        return await deleteTemplateDirectLink({ userId, templateId });
+      } catch (err) {
+        console.error(err);
+
+        const error = AppError.parseError(err);
+        throw AppError.parseErrorToTRPCError(error);
+      }
+    }),
+
+  toggleTemplateDirectLink: authenticatedProcedure
+    .input(ZToggleTemplateDirectLinkMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { templateId, enabled } = input;
+
+        const userId = ctx.user.id;
+
+        return await toggleTemplateDirectLink({ userId, templateId, enabled });
+      } catch (err) {
+        console.error(err);
+
+        const error = AppError.parseError(err);
+        throw AppError.parseErrorToTRPCError(error);
+      }
+    }),
 });

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

@@ -6,12 +6,21 @@ import {
   ZDocumentActionAuthTypesSchema,
 } from '@documenso/lib/types/document-auth';
 
+import { ZSignFieldWithTokenMutationSchema } from '../field-router/schema';
+
 export const ZCreateTemplateMutationSchema = z.object({
   title: z.string().min(1).trim(),
   teamId: z.number().optional(),
   templateDocumentDataId: z.string().min(1),
 });
 
+export const ZCreateDocumentFromDirectTemplateMutationSchema = z.object({
+  directRecipientEmail: z.string().email(),
+  directTemplateToken: z.string().min(1),
+  signedFieldValues: z.array(ZSignFieldWithTokenMutationSchema),
+  templateUpdatedAt: z.date(),
+});
+
 export const ZCreateDocumentFromTemplateMutationSchema = z.object({
   templateId: z.number(),
   teamId: z.number().optional(),
@@ -35,6 +44,20 @@ export const ZDuplicateTemplateMutationSchema = z.object({
   teamId: z.number().optional(),
 });
 
+export const ZCreateTemplateDirectLinkMutationSchema = z.object({
+  templateId: z.number().min(1),
+  directRecipientId: z.number().min(1).optional(),
+});
+
+export const ZDeleteTemplateDirectLinkMutationSchema = z.object({
+  templateId: z.number().min(1),
+});
+
+export const ZToggleTemplateDirectLinkMutationSchema = z.object({
+  templateId: z.number().min(1),
+  enabled: z.boolean(),
+});
+
 export const ZDeleteTemplateMutationSchema = z.object({
   id: z.number().min(1),
 });