feat: templates

packages/trpc/server/router.ts

@@ -6,6 +6,7 @@ import { profileRouter } from './profile-router/router';
 import { recipientRouter } from './recipient-router/router';
 import { shareLinkRouter } from './share-link-router/router';
 import { singleplayerRouter } from './singleplayer-router/router';
+import { templateRouter } from './template-router/router';
 import { router } from './trpc';
 import { twoFactorAuthenticationRouter } from './two-factor-authentication-router/router';
 
@@ -19,6 +20,7 @@ export const appRouter = router({
   shareLink: shareLinkRouter,
   singleplayer: singleplayerRouter,
   twoFactorAuthentication: twoFactorAuthenticationRouter,
+  template: templateRouter,
 });
 
 export type AppRouter = typeof appRouter;

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

@@ -0,0 +1,94 @@
+import { TRPCError } from '@trpc/server';
+
+import { createDocumentFromTemplate } from '@documenso/lib/server-only/template/create-document-from-template';
+import { createTemplate } from '@documenso/lib/server-only/template/create-template';
+import { deleteTemplate } from '@documenso/lib/server-only/template/delete-template';
+import { duplicateTemplate } from '@documenso/lib/server-only/template/duplicate-template';
+
+import { authenticatedProcedure, router } from '../trpc';
+import {
+  ZCreateDocumentFromTemplateMutationSchema,
+  ZCreateTemplateMutationSchema,
+  ZDeleteTemplateMutationSchema,
+  ZDuplicateTemplateMutationSchema,
+} from './schema';
+
+export const templateRouter = router({
+  createTemplate: authenticatedProcedure
+    .input(ZCreateTemplateMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { title, templateDocumentDataId } = input;
+
+        return await createTemplate({
+          title,
+          userId: ctx.user.id,
+          templateDocumentDataId,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to create this template. Please try again later.',
+        });
+      }
+    }),
+
+  createDocumentFromTemplate: authenticatedProcedure
+    .input(ZCreateDocumentFromTemplateMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { templateId } = input;
+
+        return await createDocumentFromTemplate({
+          templateId,
+          userId: ctx.user.id,
+        });
+      } catch (err) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to create this document. Please try again later.',
+        });
+      }
+    }),
+
+  duplicateTemplate: authenticatedProcedure
+    .input(ZDuplicateTemplateMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { templateId } = input;
+
+        return await duplicateTemplate({
+          templateId,
+          userId: ctx.user.id,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to duplicate the template. Please try again later.',
+        });
+      }
+    }),
+
+  deleteTemplate: authenticatedProcedure
+    .input(ZDeleteTemplateMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { id } = input;
+
+        const userId = ctx.user.id;
+
+        return await deleteTemplate({ id, userId });
+      } catch (err) {
+        console.error(err);
+
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to delete this template. Please try again later.',
+        });
+      }
+    }),
+});

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+export const ZCreateTemplateMutationSchema = z.object({
+  title: z.string().min(1),
+  templateDocumentDataId: z.string().min(1),
+});
+
+export const ZCreateDocumentFromTemplateMutationSchema = z.object({
+  templateId: z.number(),
+});
+
+export const ZDuplicateTemplateMutationSchema = z.object({
+  templateId: z.number(),
+});
+
+export const ZDeleteTemplateMutationSchema = z.object({
+  id: z.number().min(1),
+});
+
+export type TCreateTemplateMutationSchema = z.infer<typeof ZCreateTemplateMutationSchema>;
+export type TCreateDocumentFromTemplateMutationSchema = z.infer<
+  typeof ZCreateDocumentFromTemplateMutationSchema
+>;
+
+export type TDuplicateTemplateMutationSchema = z.infer<typeof ZDuplicateTemplateMutationSchema>;
+export type TDeleteTemplateMutationSchema = z.infer<typeof ZDeleteTemplateMutationSchema>;