Refactor Webhooks page

src/app/dashboard/[teamSlug]/webhooks/page.tsx

@@ -1,60 +1,29 @@
 import { notFound } from 'next/navigation'
 import { INCLUDE_ARGUS } from '@/configs/flags'
-import WebhookAddEditDialog from '@/features/dashboard/settings/webhooks/add-edit-dialog'
-import WebhooksTable from '@/features/dashboard/settings/webhooks/table'
-import Frame from '@/ui/frame'
-import { Button } from '@/ui/primitives/button'
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-} from '@/ui/primitives/card'
-import { AddIcon } from '@/ui/primitives/icons'
+import { Page } from '@/features/dashboard/layouts/page'
+import { WebhooksPageContent } from '@/features/dashboard/settings/webhooks/webhooks-page-content'
+import { HydrateClient, prefetch, trpc } from '@/trpc/server'
 
-interface WebhooksPageClientProps {
+interface WebhooksPageProps {
   params: Promise<{
     teamSlug: string
   }>
 }
 
-export default async function WebhooksPage({
-  params,
-}: WebhooksPageClientProps) {
+export default async function WebhooksPage({ params }: WebhooksPageProps) {
   if (!INCLUDE_ARGUS) {
     return notFound()
   }
 
-  return (
-    <Frame
-      classNames={{
-        wrapper: 'w-full max-md:p-0',
-        frame: 'max-md:border-none',
-      }}
-    >
-      <Card className="w-full">
-        <CardHeader>
-          <div className="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between sm:gap-6">
-            <CardDescription className="max-w-[600px] text-fg">
-              Webhooks allow your external service to be notified when sandbox
-              lifecycle events happen. When the specified event happens, we'll
-              send a POST request to the configured URLs.
-            </CardDescription>
+  const { teamSlug } = await params
 
-            <WebhookAddEditDialog mode="add">
-              <Button className="w-full sm:w-auto sm:self-start">
-                <AddIcon className="size-4" /> Add Webhook
-              </Button>
-            </WebhookAddEditDialog>
-          </div>
-        </CardHeader>
+  prefetch(trpc.webhooks.list.queryOptions({ teamSlug }))
 
-        <CardContent>
-          <div className="w-full overflow-x-auto">
-            <WebhooksTable params={params} className="min-w-[900px]" />
-          </div>
-        </CardContent>
-      </Card>
-    </Frame>
+  return (
+    <HydrateClient>
+      <Page>
+        <WebhooksPageContent />
+      </Page>
+    </HydrateClient>
   )
 }

src/core/modules/sandboxes/lifecycle-event-types.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+const SandboxLifecycleEventTypeSchema = z.enum([
+  'sandbox.lifecycle.created',
+  'sandbox.lifecycle.updated',
+  'sandbox.lifecycle.paused',
+  'sandbox.lifecycle.resumed',
+  'sandbox.lifecycle.killed',
+])
+
+type SandboxLifecycleEventType = z.infer<typeof SandboxLifecycleEventTypeSchema>
+
+export { SandboxLifecycleEventTypeSchema, type SandboxLifecycleEventType }

src/core/modules/webhooks/repository.server.ts

@@ -15,7 +15,7 @@ type WebhooksRepositoryDeps = {
 export type WebhooksScope = TeamRequestScope
 
 export interface UpsertWebhookInput {
-  mode: 'create' | 'edit'
+  mode: 'create' | 'update'
   webhookId?: string
   name: string
   url: string
@@ -68,34 +68,68 @@ export function createWebhooksRepository(
       return ok(response.data ?? [])
     },
     async upsertWebhook(input) {
-      const response =
-        input.mode === 'edit'
-          ? await deps.infraClient.PATCH('/events/webhooks/{webhookID}', {
-              headers: {
-                ...deps.authHeaders(scope.accessToken, scope.teamId),
-              },
-              params: {
-                path: { webhookID: input.webhookId ?? '' },
-              },
-              body: {
-                name: input.name,
-                url: input.url,
-                events: input.events,
-                enabled: input.enabled,
-              },
-            })
-          : await deps.infraClient.POST('/events/webhooks', {
-              headers: {
-                ...deps.authHeaders(scope.accessToken, scope.teamId),
-              },
-              body: {
-                name: input.name,
-                url: input.url,
-                events: input.events,
-                enabled: input.enabled,
-                signatureSecret: input.signatureSecret ?? '',
-              },
-            })
+      if (input.mode === 'update') {
+        if (!input.webhookId) {
+          return err(
+            repoErrorFromHttp(
+              400,
+              'webhookId is required when updating a webhook'
+            )
+          )
+        }
+
+        const response = await deps.infraClient.PATCH(
+          '/events/webhooks/{webhookID}',
+          {
+            headers: {
+              ...deps.authHeaders(scope.accessToken, scope.teamId),
+            },
+            params: {
+              path: { webhookID: input.webhookId },
+            },
+            body: {
+              name: input.name,
+              url: input.url,
+              events: input.events,
+              enabled: input.enabled,
+            },
+          }
+        )
+
+        if (!response.response.ok || response.error) {
+          return err(
+            repoErrorFromHttp(
+              response.response.status,
+              response.error?.message ?? 'Failed to upsert webhook',
+              response.error
+            )
+          )
+        }
+
+        return ok(undefined)
+      }
+
+      if (!input.signatureSecret) {
+        return err(
+          repoErrorFromHttp(
+            400,
+            'signatureSecret is required when creating a webhook'
+          )
+        )
+      }
+
+      const response = await deps.infraClient.POST('/events/webhooks', {
+        headers: {
+          ...deps.authHeaders(scope.accessToken, scope.teamId),
+        },
+        body: {
+          name: input.name,
+          url: input.url,
+          events: input.events,
+          enabled: input.enabled,
+          signatureSecret: input.signatureSecret,
+        },
+      })
 
       if (!response.response.ok || response.error) {
         return err(

src/core/server/api/routers/index.ts

@@ -6,6 +6,7 @@ import { sandboxesRouter } from './sandboxes'
 import { supportRouter } from './support'
 import { teamsRouter } from './teams'
 import { templatesRouter } from './templates'
+import { webhooksRouter } from './webhooks'
 
 export const trpcAppRouter = createTRPCRouter({
   sandbox: sandboxRouter,
@@ -15,6 +16,7 @@ export const trpcAppRouter = createTRPCRouter({
   billing: billingRouter,
   support: supportRouter,
   teams: teamsRouter,
+  webhooks: webhooksRouter,
 })
 
 export type TRPCAppRouter = typeof trpcAppRouter