Merge branch 'main' into feat/public-profile-1

packages/trpc/server/router.ts

@@ -12,6 +12,7 @@ import { teamRouter } from './team-router/router';
 import { templateRouter } from './template-router/router';
 import { router } from './trpc';
 import { twoFactorAuthenticationRouter } from './two-factor-authentication-router/router';
+import { webhookRouter } from './webhook-router/router';
 
 export const appRouter = router({
   auth: authRouter,
@@ -26,6 +27,7 @@ export const appRouter = router({
   singleplayer: singleplayerRouter,
   team: teamRouter,
   template: templateRouter,
+  webhook: webhookRouter,
   twoFactorAuthentication: twoFactorAuthenticationRouter,
 });
 

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

@@ -0,0 +1,125 @@
+import { TRPCError } from '@trpc/server';
+
+import { createWebhook } from '@documenso/lib/server-only/webhooks/create-webhook';
+import { deleteWebhookById } from '@documenso/lib/server-only/webhooks/delete-webhook-by-id';
+import { editWebhook } from '@documenso/lib/server-only/webhooks/edit-webhook';
+import { getWebhookById } from '@documenso/lib/server-only/webhooks/get-webhook-by-id';
+import { getWebhooksByTeamId } from '@documenso/lib/server-only/webhooks/get-webhooks-by-team-id';
+import { getWebhooksByUserId } from '@documenso/lib/server-only/webhooks/get-webhooks-by-user-id';
+
+import { authenticatedProcedure, router } from '../trpc';
+import {
+  ZCreateWebhookMutationSchema,
+  ZDeleteWebhookMutationSchema,
+  ZEditWebhookMutationSchema,
+  ZGetTeamWebhooksQuerySchema,
+  ZGetWebhookByIdQuerySchema,
+} from './schema';
+
+export const webhookRouter = router({
+  getWebhooks: authenticatedProcedure.query(async ({ ctx }) => {
+    try {
+      return await getWebhooksByUserId(ctx.user.id);
+    } catch (err) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'We were unable to fetch your webhooks. Please try again later.',
+      });
+    }
+  }),
+
+  getTeamWebhooks: authenticatedProcedure
+    .input(ZGetTeamWebhooksQuerySchema)
+    .query(async ({ ctx, input }) => {
+      const { teamId } = input;
+
+      try {
+        return await getWebhooksByTeamId(teamId, ctx.user.id);
+      } catch (err) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to fetch your webhooks. Please try again later.',
+        });
+      }
+    }),
+
+  getWebhookById: authenticatedProcedure
+    .input(ZGetWebhookByIdQuerySchema)
+    .query(async ({ input, ctx }) => {
+      try {
+        const { id, teamId } = input;
+
+        return await getWebhookById({
+          id,
+          userId: ctx.user.id,
+          teamId,
+        });
+      } catch (err) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to fetch your webhook. Please try again later.',
+        });
+      }
+    }),
+
+  createWebhook: authenticatedProcedure
+    .input(ZCreateWebhookMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { enabled, eventTriggers, secret, webhookUrl, teamId } = input;
+
+      try {
+        return await createWebhook({
+          enabled,
+          secret,
+          webhookUrl,
+          eventTriggers,
+          teamId,
+          userId: ctx.user.id,
+        });
+      } catch (err) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to create this webhook. Please try again later.',
+        });
+      }
+    }),
+
+  deleteWebhook: authenticatedProcedure
+    .input(ZDeleteWebhookMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { id, teamId } = input;
+
+        return await deleteWebhookById({
+          id,
+          teamId,
+          userId: ctx.user.id,
+        });
+      } catch (err) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to create this webhook. Please try again later.',
+        });
+      }
+    }),
+
+  editWebhook: authenticatedProcedure
+    .input(ZEditWebhookMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { id, teamId, ...data } = input;
+
+        return await editWebhook({
+          id,
+          data,
+          userId: ctx.user.id,
+          teamId,
+        });
+      } catch (err) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'We were unable to create this webhook. Please try again later.',
+        });
+      }
+    }),
+});

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+
+import { WebhookTriggerEvents } from '@documenso/prisma/client';
+
+export const ZGetTeamWebhooksQuerySchema = z.object({
+  teamId: z.number(),
+});
+
+export type TGetTeamWebhooksQuerySchema = z.infer<typeof ZGetTeamWebhooksQuerySchema>;
+
+export const ZCreateWebhookMutationSchema = z.object({
+  webhookUrl: z.string().url(),
+  eventTriggers: z
+    .array(z.nativeEnum(WebhookTriggerEvents))
+    .min(1, { message: 'At least one event trigger is required' }),
+  secret: z.string().nullable(),
+  enabled: z.boolean(),
+  teamId: z.number().optional(),
+});
+
+export type TCreateWebhookFormSchema = z.infer<typeof ZCreateWebhookMutationSchema>;
+
+export const ZGetWebhookByIdQuerySchema = z.object({
+  id: z.string(),
+  teamId: z.number().optional(),
+});
+
+export type TGetWebhookByIdQuerySchema = z.infer<typeof ZGetWebhookByIdQuerySchema>;
+
+export const ZEditWebhookMutationSchema = ZCreateWebhookMutationSchema.extend({
+  id: z.string(),
+});
+
+export type TEditWebhookMutationSchema = z.infer<typeof ZEditWebhookMutationSchema>;
+
+export const ZDeleteWebhookMutationSchema = z.object({
+  id: z.string(),
+  teamId: z.number().optional(),
+});
+
+export type TDeleteWebhookMutationSchema = z.infer<typeof ZDeleteWebhookMutationSchema>;