fix site and resource filters on alert

server/private/routers/alertRule/listAlertRules.ts

@@ -14,14 +14,19 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { alertRules, alertSites, alertHealthChecks, alertResources } from "@server/db";
+import {
+    alertRules,
+    alertSites,
+    alertHealthChecks,
+    alertResources
+} from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
-import { and, asc, desc, eq, inArray, like, sql } from "drizzle-orm";
+import { and, asc, desc, eq, inArray, like, or, sql } from "drizzle-orm";
 
 const paramsSchema = z.strictObject({
     orgId: z.string().nonempty()
@@ -51,11 +56,34 @@ const querySchema = z.strictObject({
         .optional()
         .transform((v) => (v !== undefined ? Number(v) : undefined))
         .pipe(z.number().int().positive().optional()),
+    healthCheckId: z
+        .string()
+        .optional()
+        .transform((v) => (v !== undefined ? Number(v) : undefined))
+        .pipe(z.number().int().positive().optional()),
     sort_by: z.enum(["name", "last_triggered_at"]).optional(),
     order: z.enum(["asc", "desc"]).optional().default("asc"),
     enabled: z.enum(["true", "false"]).optional()
 });
 
+const SITE_ALERT_EVENT_TYPES = [
+    "site_online",
+    "site_offline",
+    "site_toggle"
+] as const;
+
+const RESOURCE_ALERT_EVENT_TYPES = [
+    "resource_healthy",
+    "resource_unhealthy",
+    "resource_toggle"
+] as const;
+
+const HEALTH_CHECK_ALERT_EVENT_TYPES = [
+    "health_check_healthy",
+    "health_check_unhealthy",
+    "health_check_toggle"
+] as const;
+
 export type ListAlertRulesResponse = {
     alertRules: {
         alertRuleId: number;
@@ -122,66 +150,110 @@ export async function listAlertRules(
             query,
             siteId,
             resourceId,
+            healthCheckId,
             sort_by,
             order,
             enabled: enabledFilter
         } = parsedQuery.data;
 
-        // Resolve siteId filter → matching alertRuleIds
+        const explicitSiteRuleIds: number[] =
-        let siteFilterRuleIds: number[] | null = null;
+            siteId !== undefined
-        if (siteId !== undefined) {
+                ? (
-            const rows = await db
+                      await db
-                .select({ alertRuleId: alertSites.alertRuleId })
+                          .select({ alertRuleId: alertSites.alertRuleId })
-                .from(alertSites)
+                          .from(alertSites)
-                .where(eq(alertSites.siteId, siteId));
+                          .where(eq(alertSites.siteId, siteId))
-            siteFilterRuleIds = rows.map((r) => r.alertRuleId);
+                  ).map((r) => r.alertRuleId)
-            if (siteFilterRuleIds.length === 0) {
+                : [];
-                return response<ListAlertRulesResponse>(res, {
-                    data: {
-                        alertRules: [],
-                        pagination: { total: 0, limit, offset }
-                    },
-                    success: true,
-                    error: false,
-                    message: "Alert rules retrieved successfully",
-                    status: HttpCode.OK
-                });
-            }
-        }
 
-        // Resolve resourceId filter → matching alertRuleIds
+        const explicitResourceRuleIds: number[] =
-        let resourceFilterRuleIds: number[] | null = null;
+            resourceId !== undefined
-        if (resourceId !== undefined) {
+                ? (
-            const rows = await db
+                      await db
-                .select({ alertRuleId: alertResources.alertRuleId })
+                          .select({
-                .from(alertResources)
+                              alertRuleId: alertResources.alertRuleId
-                .where(eq(alertResources.resourceId, resourceId));
+                          })
-            resourceFilterRuleIds = rows.map((r) => r.alertRuleId);
+                          .from(alertResources)
-            if (resourceFilterRuleIds.length === 0) {
+                          .where(eq(alertResources.resourceId, resourceId))
-                return response<ListAlertRulesResponse>(res, {
+                  ).map((r) => r.alertRuleId)
-                    data: {
+                : [];
-                        alertRules: [],
+
-                        pagination: { total: 0, limit, offset }
+        const explicitHealthCheckRuleIds: number[] =
-                    },
+            healthCheckId !== undefined
-                    success: true,
+                ? (
-                    error: false,
+                      await db
-                    message: "Alert rules retrieved successfully",
+                          .select({
-                    status: HttpCode.OK
+                              alertRuleId: alertHealthChecks.alertRuleId
-                });
+                          })
-            }
+                          .from(alertHealthChecks)
-        }
+                          .where(
+                              eq(alertHealthChecks.healthCheckId, healthCheckId)
+                          )
+                  ).map((r) => r.alertRuleId)
+                : [];
+
+        const allSitesWildcardClause = and(
+            eq(alertRules.allSites, true),
+            inArray(alertRules.eventType, SITE_ALERT_EVENT_TYPES)
+        );
+
+        const siteScopeClause =
+            siteId !== undefined
+                ? explicitSiteRuleIds.length > 0
+                    ? or(
+                          allSitesWildcardClause,
+                          inArray(alertRules.alertRuleId, explicitSiteRuleIds)
+                      )
+                    : allSitesWildcardClause
+                : undefined;
+
+        const allResourcesWildcardClause = and(
+            eq(alertRules.allResources, true),
+            inArray(alertRules.eventType, RESOURCE_ALERT_EVENT_TYPES)
+        );
+
+        const resourceScopeClause =
+            resourceId !== undefined
+                ? explicitResourceRuleIds.length > 0
+                    ? or(
+                          allResourcesWildcardClause,
+                          inArray(
+                              alertRules.alertRuleId,
+                              explicitResourceRuleIds
+                          )
+                      )
+                    : allResourcesWildcardClause
+                : undefined;
+
+        const allHealthChecksWildcardClause = and(
+            eq(alertRules.allHealthChecks, true),
+            inArray(alertRules.eventType, HEALTH_CHECK_ALERT_EVENT_TYPES)
+        );
+
+        const healthCheckScopeClause =
+            healthCheckId !== undefined
+                ? explicitHealthCheckRuleIds.length > 0
+                    ? or(
+                          allHealthChecksWildcardClause,
+                          inArray(
+                              alertRules.alertRuleId,
+                              explicitHealthCheckRuleIds
+                          )
+                      )
+                    : allHealthChecksWildcardClause
+                : undefined;
 
         const whereClause = and(
             eq(alertRules.orgId, orgId),
             query
-                ? like(sql`LOWER(${alertRules.name})`, `%${query.toLowerCase()}%`)
+                ? like(
-                : undefined,
+                      sql`LOWER(${alertRules.name})`,
-            siteFilterRuleIds !== null
+                      `%${query.toLowerCase()}%`
-                ? inArray(alertRules.alertRuleId, siteFilterRuleIds)
+                  )
-                : undefined,
-            resourceFilterRuleIds !== null
-                ? inArray(alertRules.alertRuleId, resourceFilterRuleIds)
                 : undefined,
+            siteScopeClause,
+            resourceScopeClause,
+            healthCheckScopeClause,
             enabledFilter !== undefined
                 ? eq(alertRules.enabled, enabledFilter === "true")
                 : undefined
@@ -228,9 +300,7 @@ export async function listAlertRules(
                 ? await db
                       .select()
                       .from(alertHealthChecks)
-                      .where(
+                      .where(inArray(alertHealthChecks.alertRuleId, ruleIds))
-                          inArray(alertHealthChecks.alertRuleId, ruleIds)
-                      )
                 : [];
 
         const resourceRows =
@@ -297,4 +367,4 @@ export async function listAlertRules(
             createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred")
         );
     }
-}
+}

src/app/[orgId]/settings/alerting/(list)/rules/page.tsx

@@ -46,6 +46,9 @@ export default async function AlertingRulesPage(props: AlertingRulesPageProps) {
     const resourceId = parsePositiveInt(
         searchParams.get("resourceId") ?? undefined
     );
+    const healthCheckId = parsePositiveInt(
+        searchParams.get("healthCheckId") ?? undefined
+    );
 
     const apiSp = new URLSearchParams();
     apiSp.set("limit", String(pageSize));
@@ -53,6 +56,8 @@ export default async function AlertingRulesPage(props: AlertingRulesPageProps) {
     if (query) apiSp.set("query", query);
     if (siteId != null) apiSp.set("siteId", String(siteId));
     if (resourceId != null) apiSp.set("resourceId", String(resourceId));
+    if (healthCheckId != null)
+        apiSp.set("healthCheckId", String(healthCheckId));
     if (sortBy) {
         apiSp.set("sort_by", sortBy);
         if (order) apiSp.set("order", order);

src/components/UptimeAlertSection.tsx

@@ -51,7 +51,9 @@ export default function UptimeAlertSection({
     const queryClient = useQueryClient();
 
     const [open, setOpen] = useState(false);
-    const [name, setName] = useState(`${siteId ? "Site" : "Resource"} ${startingName} Alert`);
+    const [name, setName] = useState(
+        `${siteId ? "Site" : "Resource"} ${startingName} Alert`
+    );
     const [userTags, setUserTags] = useState<Tag[]>([]);
     const [roleTags, setRoleTags] = useState<Tag[]>([]);
     const [emailTags, setEmailTags] = useState<Tag[]>([]);
@@ -129,8 +131,7 @@ export default function UptimeAlertSection({
 
             toast({
                 title: "Alert created",
-                description:
+                description: "You will be notified when this changes status."
-                    "You will be notified when this changes status."
             });
 
             setOpen(false);
@@ -156,11 +157,17 @@ export default function UptimeAlertSection({
         setLoading(false);
     }
 
+    const rulesListSearch = new URLSearchParams();
+    if (siteId != null) rulesListSearch.set("siteId", String(siteId));
+    if (resourceId != null)
+        rulesListSearch.set("resourceId", String(resourceId));
+    const rulesListHref = `/${orgId}/settings/alerting/rules${
+        rulesListSearch.toString() ? `?${rulesListSearch}` : ""
+    }`;
+
     const alertButton = alertRulesLoading ? null : hasRules ? (
         <Button variant="outline" asChild>
-            <Link
+            <Link href={rulesListHref}>
-                href={`/${orgId}/settings/alerting/rules?siteId=${siteId}&resourceId=${resourceId}`}
-            >
                 <BellRing className="size-4 mr-2" />
                 View Alerts
             </Link>
@@ -201,8 +208,8 @@ export default function UptimeAlertSection({
                         <CredenzaTitle>Create Email Alert</CredenzaTitle>
                         <CredenzaDescription>
                             Get notified by email when this{" "}
-                            {siteId ? "site" : "resource"} goes offline or
+                            {siteId ? "site" : "resource"} goes offline or comes
-                            comes back online.
+                            back online.
                         </CredenzaDescription>
                     </CredenzaHeader>
                     <CredenzaBody>

src/lib/queries.ts

@@ -1,7 +1,10 @@
 import { build } from "@server/build";
 import type { QueryRequestAnalyticsResponse } from "@server/routers/auditLogs";
 import type { ListClientsResponse } from "@server/routers/client";
-import type { ListDomainsResponse, GetDNSRecordsResponse } from "@server/routers/domain";
+import type {
+    ListDomainsResponse,
+    GetDNSRecordsResponse
+} from "@server/routers/domain";
 import type { GetDomainResponse } from "@server/routers/domain/getDomain";
 import type {
     GetResourceWhitelistResponse,
@@ -263,6 +266,7 @@ export const orgQueries = {
         query,
         siteId,
         resourceId,
+        healthCheckId,
         sortBy,
         order,
         enabled
@@ -273,6 +277,7 @@ export const orgQueries = {
         query?: string;
         siteId?: number;
         resourceId?: number;
+        healthCheckId?: number;
         sortBy?: string;
         order?: string;
         enabled?: string;
@@ -282,7 +287,17 @@ export const orgQueries = {
                 "ORG",
                 orgId,
                 "ALERT_RULES",
-                { limit, offset, query, siteId, resourceId, sortBy, order, enabled }
+                {
+                    limit,
+                    offset,
+                    query,
+                    siteId,
+                    resourceId,
+                    healthCheckId,
+                    sortBy,
+                    order,
+                    enabled
+                }
             ] as const,
             queryFn: async ({ signal, meta }) => {
                 const sp = new URLSearchParams();
@@ -290,7 +305,10 @@ export const orgQueries = {
                 sp.set("offset", String(offset));
                 if (query) sp.set("query", query);
                 if (siteId != null) sp.set("siteId", String(siteId));
-                if (resourceId != null) sp.set("resourceId", String(resourceId));
+                if (resourceId != null)
+                    sp.set("resourceId", String(resourceId));
+                if (healthCheckId != null)
+                    sp.set("healthCheckId", String(healthCheckId));
                 if (sortBy) {
                     sp.set("sort_by", sortBy);
                     if (order) sp.set("order", order);
@@ -309,18 +327,29 @@ export const orgQueries = {
     alertRulesForSource: ({
         orgId,
         siteId,
-        resourceId
+        resourceId,
+        healthCheckId
     }: {
         orgId: string;
         siteId?: number;
         resourceId?: number;
+        healthCheckId?: number;
     }) =>
         queryOptions({
-            queryKey: ["ORG", orgId, "ALERT_RULES", { siteId, resourceId }] as const,
+            queryKey: [
+                "ORG",
+                orgId,
+                "ALERT_RULES",
+                { siteId, resourceId, healthCheckId }
+            ] as const,
             queryFn: async ({ signal, meta }) => {
                 const sp = new URLSearchParams();
-                if (siteId != null) sp.set("siteId", String(siteId));
+                if (siteId != null && siteId !== undefined)
-                if (resourceId != null) sp.set("resourceId", String(resourceId));
+                    sp.set("siteId", String(siteId));
+                if (resourceId != null && resourceId !== undefined)
+                    sp.set("resourceId", String(resourceId));
+                if (healthCheckId != null && healthCheckId !== undefined)
+                    sp.set("healthCheckId", String(healthCheckId));
                 const res = await meta!.api.get<
                     AxiosResponse<ListAlertRulesResponse>
                 >(`/org/${orgId}/alert-rules?${sp.toString()}`, { signal });
@@ -340,7 +369,12 @@ export const orgQueries = {
         query?: string;
     }) =>
         queryOptions({
-            queryKey: ["ORG", orgId, "STANDALONE_HEALTH_CHECKS", { limit, offset, query }] as const,
+            queryKey: [
+                "ORG",
+                orgId,
+                "STANDALONE_HEALTH_CHECKS",
+                { limit, offset, query }
+            ] as const,
             queryFn: async ({ signal, meta }) => {
                 const sp = new URLSearchParams();
                 sp.set("limit", String(limit));
@@ -417,7 +451,9 @@ export const orgQueries = {
             queryFn: async ({ signal, meta }) => {
                 const res = await meta!.api.get<
                     AxiosResponse<StatusHistoryResponse>
-                >(`/resource/${resourceId}/status-history?days=${days}`, { signal });
+                >(`/resource/${resourceId}/status-history?days=${days}`, {
+                    signal
+                });
                 return res.data.data;
             }
         }),
@@ -692,13 +728,7 @@ export const approvalQueries = {
 };
 
 export const domainQueries = {
-    getDomain: ({
+    getDomain: ({ orgId, domainId }: { orgId: string; domainId: string }) =>
-        orgId,
-        domainId
-    }: {
-        orgId: string;
-        domainId: string;
-    }) =>
         queryOptions({
             queryKey: ["ORG", orgId, "DOMAIN", domainId] as const,
             queryFn: async ({ signal, meta }) => {
@@ -709,13 +739,7 @@ export const domainQueries = {
             },
             refetchInterval: durationToMs(10, "seconds")
         }),
-    getDNSRecords: ({
+    getDNSRecords: ({ orgId, domainId }: { orgId: string; domainId: string }) =>
-        orgId,
-        domainId
-    }: {
-        orgId: string;
-        domainId: string;
-    }) =>
         queryOptions({
             queryKey: [
                 "ORG",
@@ -727,10 +751,7 @@ export const domainQueries = {
             queryFn: async ({ signal, meta }) => {
                 const res = await meta!.api.get<
                     AxiosResponse<GetDNSRecordsResponse>
-                >(
+                >(`/org/${orgId}/domain/${domainId}/dns-records`, { signal });
-                    `/org/${orgId}/domain/${domainId}/dns-records`,
-                    { signal }
-                );
                 return res.data.data;
             },
             refetchInterval: durationToMs(10, "seconds")