📟 pagerduty fix (#1161)

* 📟 pagerduty fix

* 📟

* typo

* 📟 pagerduty

* 📟 pagerduty

* ci: apply automated fixes

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

apps/web/src/app/api/callback/pagerduty/route.ts

···
+import { redirect } from "next/navigation";
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const workspace = searchParams.get("workspace");
+  const url = `${
+    process.env.NODE_ENV === "development" // FIXME: This sucks
+      ? "http://localhost:3000"
+      : "https://www.openstatus.dev"
+  }/app/${workspace}/notifications/new/pagerduty?${searchParams}`;
+  redirect(url);
+}

apps/web/src/app/app/[workspaceSlug]/(dashboard)/notifications/(overview)/_components/channel-table.tsx

···
+import { env } from "@/env";
 import type { Workspace } from "@openstatus/db/src/schema";
 import { getLimit } from "@openstatus/db/src/schema/plan/utils";
 
···
         <Channel
           title="PagerDuty"
           description="Send notifications to PagerDuty."
-          href={`https://app.pagerduty.com/install/integration?app_id=PN76M56&redirect_url=${
+          href={`https://app.pagerduty.com/install/integration?app_id=${env.PAGERDUTY_APP_ID}&redirect_url=${
             process.env.NODE_ENV === "development" // FIXME: This sucks
               ? "http://localhost:3000"
               : "https://www.openstatus.dev"
-          }/app/${workspace.slug}/notifications/new/pagerduty&version=2`}
+          }/api/callback/pagerduty?workspace=${workspace.slug}&version=2`}
           disabled={disabled || !workspace.limits.pagerduty}
         />
         <Separator />

apps/web/src/components/forms/notification/provider/actions.ts

···
 "use server";
 
-import { sendTest } from "@openstatus/notification-opsgenie";
+import { sendTest as sendOpsGenieAlert } from "@openstatus/notification-opsgenie";
 
+import { sendTest as sendPagerDutyAlert } from "@openstatus/notification-pagerduty";
 export async function sendOpsGenieTestAlert(
   apiKey: string,
   region: "us" | "eu",
 ) {
-  const isSuccessfull = await sendTest({ apiKey, region });
+  const isSuccessfull = await sendOpsGenieAlert({ apiKey, region });
+  return isSuccessfull;
+}
+
+export async function sendPagerDutyTestAlert(integrationKey: string) {
+  const isSuccessfull = await sendPagerDutyAlert({
+    integrationKey: integrationKey,
+  });
   return isSuccessfull;
 }

apps/web/src/components/forms/notification/provider/section-pagerduty.tsx

···
 
 import type { UseFormReturn } from "react-hook-form";
 
-import type {
-  InsertNotificationWithData,
-  WorkspacePlan,
+import { LoadingAnimation } from "@/components/loading-animation";
+import { toastAction } from "@/lib/toast";
+import {
+  type InsertNotificationWithData,
+  InsertNotificationWithDataSchema,
+  NotificationDataSchema,
+  type WorkspacePlan,
+  selectNotificationSchema,
 } from "@openstatus/db/src/schema";
+import { PagerDutySchema } from "@openstatus/notification-pagerduty";
+import { Button } from "@openstatus/ui";
+import { useSearchParams } from "next/navigation";
+import { useTransition } from "react";
+import { sendPagerDutyTestAlert } from "./actions";
 
 interface Props {
   form: UseFormReturn<InsertNotificationWithData>;
···
 }
 
 export function SectionPagerDuty({ form }: Props) {
-  return null;
+  const [isTestPending, startTestTransition] = useTransition();
+  const searchParams = useSearchParams();
+
+  const config = searchParams.get("config");
+
+  const result = PagerDutySchema.safeParse(JSON.parse(config || ""));
+  // We should fix that but that's not working for editing pagerduty notifications
+  if (result.success === false) {
+    return null;
+  }
+
+  const data = result.data;
+
+  async function sendTestAlert() {
+    startTestTransition(async () => {
+      const isSuccessfull = await sendPagerDutyTestAlert(
+        data.integration_keys[0].integration_key,
+      );
+      if (isSuccessfull) {
+        toastAction("test-success");
+      } else {
+        toastAction("test-error");
+      }
+    });
+  }
+
+  return (
+    <div className="col-span-full text-right">
+      <Button
+        type="button"
+        variant="secondary"
+        className="w-full sm:w-auto"
+        onClick={sendTestAlert}
+      >
+        {!isTestPending ? "Test Alert" : <LoadingAnimation variant="inverse" />}
+      </Button>
+    </div>
+  );
 }

apps/web/src/middleware.ts

···
     // "/node_modules/function-bind/**",
     // "**/node_modules/.pnpm/**/function-bind/**",
     // "../../packages/analytics/src/index.ts",
-    "**/node_modules/.pnpm/@jitsu*/**",
   ],
 };

packages/notifications/pagerduty/src/index.ts

···
   const notificationData = PagerDutySchema.parse(JSON.parse(notification.data));
   const { name } = monitor;
 
-  const event = triggerEventPayloadSchema.parse({
-    rounting_key: notificationData.integration_keys[0].integration_key,
-    dedup_key: `${monitor.id}}-${incidentId}`,
-    event_action: "trigger",
-    payload: {
-      summary: `${name} is down`,
-      source: "Open Status",
-      severity: "error",
-      timestamp: new Date(cronTimestamp).toISOString(),
-      custom_details: {
-        statusCode,
-        message,
-      },
-    },
-  });
-
   try {
     for await (const integrationKey of notificationData.integration_keys) {
       // biome-ignore lint/correctness/noUnusedVariables: <explanation>
       const { integration_key, type } = integrationKey;
-
+      const event = triggerEventPayloadSchema.parse({
+        routing_key: integration_key,
+        dedup_key: `${monitor.id}}-${incidentId}`,
+        event_action: "trigger",
+        payload: {
+          summary: `${name} is down`,
+          source: "Open Status",
+          severity: "error",
+          timestamp: new Date(cronTimestamp).toISOString(),
+          custom_details: {
+            statusCode,
+            message,
+          },
+        },
+      });
       await fetch("https://events.pagerduty.com/v2/enqueue", {
         method: "POST",
         body: JSON.stringify(event),
···
   const { name } = monitor;
 
   const event = triggerEventPayloadSchema.parse({
-    rounting_key: notificationData.integration_keys[0].integration_key,
+    routing_key: notificationData.integration_keys[0].integration_key,
     dedup_key: `${monitor.id}}`,
     event_action: "trigger",
     payload: {
···
   try {
     for await (const integrationKey of notificationData.integration_keys) {
       const event = resolveEventPayloadSchema.parse({
-        rounting_key: integrationKey.integration_key,
+        routing_key: integrationKey.integration_key,
         dedup_key: `${monitor.id}}-${incidentId}`,
         event_action: "resolve",
       });
···
   }
 };
 
+export const sendTest = async ({
+  integrationKey,
+}: {
+  integrationKey: string;
+}) => {
+  console.log("Sending test alert to PagerDuty");
+  try {
+    // biome-ignore lint/correctness/noUnusedVariables: <explanation>
+    const event = triggerEventPayloadSchema.parse({
+      routing_key: integrationKey,
+      dedup_key: "openstatus-test",
+      event_action: "trigger",
+      payload: {
+        summary: "This is a test from OpenStatus",
+        source: "Open Status",
+        severity: "error",
+        timestamp: new Date().toISOString(),
+        custom_details: {
+          statusCode: 418,
+          message: 'I"m a teapot',
+        },
+      },
+    });
+
+    const res = await fetch("https://events.pagerduty.com/v2/enqueue", {
+      method: "POST",
+      body: JSON.stringify(event),
+    });
+  } catch (err) {
+    console.log(err);
+    return false;
+  }
+  return true;
+};
 export { PagerDutySchema };

packages/notifications/pagerduty/src/schema/config.ts

···
 });
 
 const baseEventPayloadSchema = z.object({
-  rounting_key: z.string(),
+  routing_key: z.string(),
   dedup_key: z.string(),
 });