Add resource

server/private/lib/alerts/events/resourceEvents.ts

@@ -19,73 +19,109 @@ import { processAlerts } from "../processAlerts";
 // ---------------------------------------------------------------------------
 
 /**
- * Fire a `health_check_healthy` alert for the given health check.
+ * Fire a `resource_healthy` alert for the given resource.
  *
- * Call this after a previously-failing health check has recovered so that any
+ * Call this after a previously-unhealthy resource has recovered so that any
  * matching `alertRules` can dispatch their email and webhook actions.
  *
- * @param orgId         - Organisation that owns the health check.
- * @param healthCheckId - Numeric primary key of the health check.
- * @param healthCheckName - Human-readable name shown in notifications (optional).
- * @param extra         - Any additional key/value pairs to include in the payload.
+ * @param orgId        - Organisation that owns the resource.
+ * @param resourceId   - Numeric primary key of the resource.
+ * @param resourceName - Human-readable name shown in notifications (optional).
+ * @param extra        - Any additional key/value pairs to include in the payload.
  */
-export async function fireHealthCheckHealthyAlert(
+export async function fireResourceHealthyAlert(
     orgId: string,
-    healthCheckId: number,
-    healthCheckName?: string | null,
+    resourceId: number,
+    resourceName?: string | null,
     extra?: Record<string, unknown>
 ): Promise<void> {
     try {
         await processAlerts({
-            eventType: "health_check_healthy",
+            eventType: "resource_healthy",
             orgId,
-            healthCheckId,
+            resourceId,
             data: {
-                healthCheckId,
-                ...(healthCheckName != null ? { healthCheckName } : {}),
+                resourceId,
+                ...(resourceName != null ? { resourceName } : {}),
                 ...extra
             }
         });
     } catch (err) {
         logger.error(
-            `fireHealthCheckHealthyAlert: unexpected error for healthCheckId ${healthCheckId}`,
+            `fireResourceHealthyAlert: unexpected error for resourceId ${resourceId}`,
             err
         );
     }
 }
 
 /**
- * Fire a `health_check_unhealthy` alert for the given health check.
+ * Fire a `resource_unhealthy` alert for the given resource.
  *
- * Call this after a health check has been detected as failing so that any
+ * Call this after a resource has been detected as unhealthy so that any
  * matching `alertRules` can dispatch their email and webhook actions.
  *
- * @param orgId         - Organisation that owns the health check.
- * @param healthCheckId - Numeric primary key of the health check.
- * @param healthCheckName - Human-readable name shown in notifications (optional).
- * @param extra         - Any additional key/value pairs to include in the payload.
+ * @param orgId        - Organisation that owns the resource.
+ * @param resourceId   - Numeric primary key of the resource.
+ * @param resourceName - Human-readable name shown in notifications (optional).
+ * @param extra        - Any additional key/value pairs to include in the payload.
  */
-export async function fireHealthCheckNotHealthyAlert(
+export async function fireResourceUnhealthyAlert(
     orgId: string,
-    healthCheckId: number,
-    healthCheckName?: string | null,
+    resourceId: number,
+    resourceName?: string | null,
     extra?: Record<string, unknown>
 ): Promise<void> {
     try {
         await processAlerts({
-            eventType: "health_check_unhealthy",
+            eventType: "resource_unhealthy",
             orgId,
-            healthCheckId,
+            resourceId,
             data: {
-                healthCheckId,
-                ...(healthCheckName != null ? { healthCheckName } : {}),
+                resourceId,
+                ...(resourceName != null ? { resourceName } : {}),
                 ...extra
             }
         });
     } catch (err) {
         logger.error(
-            `fireHealthCheckNotHealthyAlert: unexpected error for healthCheckId ${healthCheckId}`,
+            `fireResourceUnhealthyAlert: unexpected error for resourceId ${resourceId}`,
             err
         );
     }
 }
+
+/**
+ * Fire a `resource_toggle` alert for the given resource.
+ *
+ * Call this when a resource's enabled/disabled status is toggled so that any
+ * matching `alertRules` can dispatch their email and webhook actions.
+ *
+ * @param orgId        - Organisation that owns the resource.
+ * @param resourceId   - Numeric primary key of the resource.
+ * @param resourceName - Human-readable name shown in notifications (optional).
+ * @param extra        - Any additional key/value pairs to include in the payload.
+ */
+export async function fireResourceToggleAlert(
+    orgId: string,
+    resourceId: number,
+    resourceName?: string | null,
+    extra?: Record<string, unknown>
+): Promise<void> {
+    try {
+        await processAlerts({
+            eventType: "resource_toggle",
+            orgId,
+            resourceId,
+            data: {
+                resourceId,
+                ...(resourceName != null ? { resourceName } : {}),
+                ...extra
+            }
+        });
+    } catch (err) {
+        logger.error(
+            `fireResourceToggleAlert: unexpected error for resourceId ${resourceId}`,
+            err
+        );
+    }
+}

server/private/lib/alerts/processAlerts.ts

@@ -17,6 +17,7 @@ import {
     alertRules,
     alertSites,
     alertHealthChecks,
+    alertResources,
     alertEmailActions,
     alertEmailRecipients,
     alertWebhookActions,
@@ -97,6 +98,24 @@ export async function processAlerts(context: AlertContext): Promise<void> {
                 )
             );
         rules = rows.map((r) => r.alertRules);
+    } else if (context.resourceId != null) {
+        const rows = await db
+            .select()
+            .from(alertRules)
+            .leftJoin(
+                alertResources,
+                eq(alertResources.alertRuleId, alertRules.alertRuleId)
+            )
+            .where(
+                and(
+                    baseConditions,
+                    or(
+                        eq(alertResources.resourceId, context.resourceId),
+                        isNull(alertResources.alertRuleId)
+                    )
+                )
+            );
+        rules = rows.map((r) => r.alertRules);
     } else {
         rules = [];
     }

server/private/lib/alerts/sendAlertEmail.ts

@@ -80,6 +80,12 @@ function buildSubject(context: AlertContext): string {
             return "[Alert] Health Check Failing";
         case "health_check_toggle":
             return "[Alert] Health Check Toggled";
+        case "resource_healthy":
+            return "[Alert] Resource Healthy";
+        case "resource_unhealthy":
+            return "[Alert] Resource Unhealthy";
+        case "resource_toggle":
+            return "[Alert] Resource Status Changed";
         default: {
             // Exhaustiveness fallback – should never be reached with a
             // well-typed caller, but keeps runtime behaviour predictable.

server/private/lib/alerts/types.ts

@@ -21,7 +21,10 @@ export type AlertEventType =
     | "site_toggle"
     | "health_check_healthy"
     | "health_check_unhealthy"
-    | "health_check_toggle";
+    | "health_check_toggle"
+    | "resource_healthy"
+    | "resource_unhealthy"
+    | "resource_toggle";
 
 // ---------------------------------------------------------------------------
 // Webhook authentication config (stored as encrypted JSON in the DB)
@@ -60,6 +63,8 @@ export interface AlertContext {
     siteId?: number;
     /** Set for health_check_* events */
     healthCheckId?: number;
+    /** Set for resource_* events */
+    resourceId?: number;
     /** Human-readable context data included in emails and webhook payloads */
     data: Record<string, unknown>;
 }