@checkstack/incident-backend 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @checkstack/incident-backend
 
+## 0.4.0
+
+### Minor Changes
+
+- c208a5b: ### @checkstack/incident-backend
+
+  Added notifications for incident status changes via the "Add Update" functionality:
+
+  - Notifications are now sent when an incident is reopened (status changed from resolved)
+  - Notifications are now sent when an incident status changes to any new value
+  - Notifications are now sent when an incident is resolved via addUpdate
+  - Extracted `notifyAffectedSystems` into a reusable module with proper importance logic:
+    - Resolved incidents always use "info" importance (good news)
+    - Reopened/created/updated incidents derive importance from severity
+
+  ### @checkstack/maintenance-backend
+
+  Fixed missing notification in `closeMaintenance` handler - the "Close" button now sends a "completed" notification to subscribers.
+
+### Patch Changes
+
+- 9551fd7: Fix creator display in incident and maintenance status updates
+
+  - Show the creator's profile name instead of UUID in status updates
+  - For maintenances, now properly displays the creator name (was missing)
+  - For incidents, replaces UUID with human-readable profile name
+  - System-generated updates (automatic maintenance transitions) show no creator
+
+- Updated dependencies [e5079e1]
+- Updated dependencies [9551fd7]
+  - @checkstack/catalog-common@1.2.6
+  - @checkstack/incident-common@0.4.2
+  - @checkstack/catalog-backend@0.2.10
+
 ## 0.3.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/incident-backend",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -10,23 +10,24 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.5.1",
-    "@checkstack/incident-common": "0.4.0",
-    "@checkstack/catalog-common": "1.2.4",
-    "@checkstack/catalog-backend": "0.2.8",
-    "@checkstack/command-backend": "0.1.7",
-    "@checkstack/signal-common": "0.1.4",
-    "@checkstack/integration-backend": "0.1.7",
-    "@checkstack/integration-common": "0.2.3",
-    "@checkstack/common": "0.6.0",
+    "@checkstack/backend-api": "0.5.2",
+    "@checkstack/incident-common": "0.4.1",
+    "@checkstack/catalog-common": "1.2.5",
+    "@checkstack/catalog-backend": "0.2.9",
+    "@checkstack/auth-common": "0.5.4",
+    "@checkstack/command-backend": "0.1.8",
+    "@checkstack/signal-common": "0.1.5",
+    "@checkstack/integration-backend": "0.1.8",
+    "@checkstack/integration-common": "0.2.4",
+    "@checkstack/common": "0.6.1",
     "drizzle-orm": "^0.45.1",
     "zod": "^4.2.1"
   },
   "devDependencies": {
-    "@checkstack/drizzle-helper": "0.0.2",
-    "@checkstack/scripts": "0.1.0",
-    "@checkstack/test-utils-backend": "0.1.7",
-    "@checkstack/tsconfig": "0.0.2",
+    "@checkstack/drizzle-helper": "0.0.3",
+    "@checkstack/scripts": "0.1.1",
+    "@checkstack/test-utils-backend": "0.1.8",
+    "@checkstack/tsconfig": "0.0.3",
     "@orpc/server": "^1.13.2",
     "@types/bun": "^1.0.0",
     "drizzle-kit": "^0.31.8",

package/src/index.ts

@@ -13,6 +13,7 @@ import { integrationEventExtensionPoint } from "@checkstack/integration-backend"
 import { IncidentService } from "./service";
 import { createRouter } from "./router";
 import { CatalogApi } from "@checkstack/catalog-common";
+import { AuthApi } from "@checkstack/auth-common";
 import { catalogHooks } from "@checkstack/catalog-backend";
 import { registerSearchProvider } from "@checkstack/command-backend";
 import { resolveRoute } from "@checkstack/common";
@@ -61,7 +62,7 @@ export default createBackendPlugin({
 
     // Register hooks as integration events
     const integrationEvents = env.getExtensionPoint(
-      integrationEventExtensionPoint
+      integrationEventExtensionPoint,
     );
 
     integrationEvents.registerEvent(
@@ -72,7 +73,7 @@ export default createBackendPlugin({
         category: "Incidents",
         payloadSchema: incidentCreatedPayloadSchema,
       },
-      pluginMetadata
+      pluginMetadata,
     );
 
     integrationEvents.registerEvent(
@@ -84,7 +85,7 @@ export default createBackendPlugin({
         category: "Incidents",
         payloadSchema: incidentUpdatedPayloadSchema,
       },
-      pluginMetadata
+      pluginMetadata,
     );
 
     integrationEvents.registerEvent(
@@ -95,7 +96,7 @@ export default createBackendPlugin({
         category: "Incidents",
         payloadSchema: incidentResolvedPayloadSchema,
       },
-      pluginMetadata
+      pluginMetadata,
     );
 
     env.registerInit({
@@ -110,15 +111,17 @@ export default createBackendPlugin({
         logger.debug("🔧 Initializing Incident Backend...");
 
         const catalogClient = rpcClient.forPlugin(CatalogApi);
+        const authClient = rpcClient.forPlugin(AuthApi);
 
         const service = new IncidentService(
-          database as SafeDatabase<typeof schema>
+          database as SafeDatabase<typeof schema>,
         );
         const router = createRouter(
           service,
           signalService,
           catalogClient,
-          logger
+          authClient,
+          logger,
         );
         rpc.registerRouter(router, incidentContract);
 
@@ -159,11 +162,11 @@ export default createBackendPlugin({
           catalogHooks.systemDeleted,
           async (payload) => {
             logger.debug(
-              `Cleaning up incident associations for deleted system: ${payload.systemId}`
+              `Cleaning up incident associations for deleted system: ${payload.systemId}`,
             );
             await service.removeSystemAssociations(payload.systemId);
           },
-          { mode: "work-queue", workerGroup: "incident-system-cleanup" }
+          { mode: "work-queue", workerGroup: "incident-system-cleanup" },
         );
 
         logger.debug("✅ Incident Backend afterPluginsReady complete.");

package/src/notifications.test.ts

@@ -0,0 +1,183 @@
+import { describe, it, expect, mock, beforeEach } from "bun:test";
+import { notifyAffectedSystems } from "./notifications";
+
+// Mock catalog client
+function createMockCatalogClient() {
+  return {
+    notifySystemSubscribers: mock(() => Promise.resolve()),
+  };
+}
+
+// Mock logger
+function createMockLogger() {
+  return {
+    warn: mock(() => {}),
+    error: mock(() => {}),
+    info: mock(() => {}),
+    debug: mock(() => {}),
+  };
+}
+
+describe("notifyAffectedSystems", () => {
+  let mockCatalogClient: ReturnType<typeof createMockCatalogClient>;
+  let mockLogger: ReturnType<typeof createMockLogger>;
+
+  beforeEach(() => {
+    mockCatalogClient = createMockCatalogClient();
+    mockLogger = createMockLogger();
+  });
+
+  describe("importance logic", () => {
+    it("should use 'info' importance for resolved action regardless of severity", async () => {
+      await notifyAffectedSystems({
+        catalogClient: mockCatalogClient as never,
+        logger: mockLogger as never,
+        incidentId: "inc-1",
+        incidentTitle: "Test Incident",
+        systemIds: ["sys-1"],
+        action: "resolved",
+        severity: "critical", // Even critical severity should be info when resolved
+      });
+
+      expect(mockCatalogClient.notifySystemSubscribers).toHaveBeenCalledWith(
+        expect.objectContaining({
+          importance: "info",
+        }),
+      );
+    });
+
+    it("should use 'critical' importance for reopened action with critical severity", async () => {
+      await notifyAffectedSystems({
+        catalogClient: mockCatalogClient as never,
+        logger: mockLogger as never,
+        incidentId: "inc-1",
+        incidentTitle: "Test Incident",
+        systemIds: ["sys-1"],
+        action: "reopened",
+        severity: "critical",
+      });
+
+      expect(mockCatalogClient.notifySystemSubscribers).toHaveBeenCalledWith(
+        expect.objectContaining({
+          importance: "critical",
+        }),
+      );
+    });
+
+    it("should use 'warning' importance for created action with major severity", async () => {
+      await notifyAffectedSystems({
+        catalogClient: mockCatalogClient as never,
+        logger: mockLogger as never,
+        incidentId: "inc-1",
+        incidentTitle: "Test Incident",
+        systemIds: ["sys-1"],
+        action: "created",
+        severity: "major",
+      });
+
+      expect(mockCatalogClient.notifySystemSubscribers).toHaveBeenCalledWith(
+        expect.objectContaining({
+          importance: "warning",
+        }),
+      );
+    });
+
+    it("should use 'info' importance for updated action with minor severity", async () => {
+      await notifyAffectedSystems({
+        catalogClient: mockCatalogClient as never,
+        logger: mockLogger as never,
+        incidentId: "inc-1",
+        incidentTitle: "Test Incident",
+        systemIds: ["sys-1"],
+        action: "updated",
+        severity: "minor",
+      });
+
+      expect(mockCatalogClient.notifySystemSubscribers).toHaveBeenCalledWith(
+        expect.objectContaining({
+          importance: "info",
+        }),
+      );
+    });
+  });
+
+  describe("action text", () => {
+    it("should use 'reported' for created action", async () => {
+      await notifyAffectedSystems({
+        catalogClient: mockCatalogClient as never,
+        logger: mockLogger as never,
+        incidentId: "inc-1",
+        incidentTitle: "Test Incident",
+        systemIds: ["sys-1"],
+        action: "created",
+        severity: "minor",
+      });
+
+      expect(mockCatalogClient.notifySystemSubscribers).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title: "Incident reported",
+          body: expect.stringContaining("reported"),
+        }),
+      );
+    });
+
+    it("should use 'reopened' for reopened action", async () => {
+      await notifyAffectedSystems({
+        catalogClient: mockCatalogClient as never,
+        logger: mockLogger as never,
+        incidentId: "inc-1",
+        incidentTitle: "Test Incident",
+        systemIds: ["sys-1"],
+        action: "reopened",
+        severity: "minor",
+      });
+
+      expect(mockCatalogClient.notifySystemSubscribers).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title: "Incident reopened",
+          body: expect.stringContaining("reopened"),
+        }),
+      );
+    });
+  });
+
+  describe("system deduplication", () => {
+    it("should deduplicate system IDs", async () => {
+      await notifyAffectedSystems({
+        catalogClient: mockCatalogClient as never,
+        logger: mockLogger as never,
+        incidentId: "inc-1",
+        incidentTitle: "Test Incident",
+        systemIds: ["sys-1", "sys-1", "sys-2", "sys-2", "sys-1"],
+        action: "created",
+        severity: "minor",
+      });
+
+      // Should only be called twice (for sys-1 and sys-2)
+      expect(mockCatalogClient.notifySystemSubscribers).toHaveBeenCalledTimes(
+        2,
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("should log warning but not throw when notification fails", async () => {
+      mockCatalogClient.notifySystemSubscribers.mockRejectedValue(
+        new Error("Network error"),
+      );
+
+      // Should not throw
+      await notifyAffectedSystems({
+        catalogClient: mockCatalogClient as never,
+        logger: mockLogger as never,
+        incidentId: "inc-1",
+        incidentTitle: "Test Incident",
+        systemIds: ["sys-1"],
+        action: "created",
+        severity: "minor",
+      });
+
+      expect(mockLogger.warn).toHaveBeenCalled();
+    });
+  });
+});

package/src/notifications.ts

@@ -0,0 +1,89 @@
+import { CatalogApi } from "@checkstack/catalog-common";
+import type { Logger } from "@checkstack/backend-api";
+import type { InferClient } from "@checkstack/common";
+import { resolveRoute } from "@checkstack/common";
+import { incidentRoutes } from "@checkstack/incident-common";
+
+/**
+ * Determines notification importance based on action and severity.
+ * Resolved actions are always "info" (good news).
+ * Other actions derive importance from severity.
+ */
+function getImportance(
+  action: "created" | "updated" | "resolved" | "reopened",
+  severity: string,
+): "info" | "warning" | "critical" {
+  // Resolved is always good news
+  if (action === "resolved") {
+    return "info";
+  }
+
+  // For other actions, derive from severity
+  if (severity === "critical") {
+    return "critical";
+  }
+  if (severity === "major") {
+    return "warning";
+  }
+  return "info";
+}
+
+/**
+ * Helper to notify subscribers of affected systems about an incident event.
+ * Each system triggers a separate notification call, but within each call
+ * the subscribers are deduplicated (system + its groups).
+ */
+export async function notifyAffectedSystems(props: {
+  catalogClient: InferClient<typeof CatalogApi>;
+  logger: Logger;
+  incidentId: string;
+  incidentTitle: string;
+  systemIds: string[];
+  action: "created" | "updated" | "resolved" | "reopened";
+  severity: string;
+}): Promise<void> {
+  const {
+    catalogClient,
+    logger,
+    incidentId,
+    incidentTitle,
+    systemIds,
+    action,
+    severity,
+  } = props;
+
+  const actionText = {
+    created: "reported",
+    updated: "updated",
+    resolved: "resolved",
+    reopened: "reopened",
+  }[action];
+
+  const importance = getImportance(action, severity);
+
+  const incidentDetailPath = resolveRoute(incidentRoutes.routes.detail, {
+    incidentId,
+  });
+
+  // Deduplicate: collect unique system IDs
+  const uniqueSystemIds = [...new Set(systemIds)];
+
+  for (const systemId of uniqueSystemIds) {
+    try {
+      await catalogClient.notifySystemSubscribers({
+        systemId,
+        title: `Incident ${actionText}`,
+        body: `Incident **"${incidentTitle}"** has been ${actionText} for a system you're subscribed to.`,
+        importance,
+        action: { label: "View Incident", url: incidentDetailPath },
+        includeGroupSubscribers: true,
+      });
+    } catch (error) {
+      // Log but don't fail the operation - notifications are best-effort
+      logger.warn(
+        `Failed to notify subscribers for system ${systemId}:`,
+        error,
+      );
+    }
+  }
+}

package/src/router.ts

@@ -2,7 +2,6 @@ import { implement, ORPCError } from "@orpc/server";
 import {
   incidentContract,
   INCIDENT_UPDATED,
-  incidentRoutes,
 } from "@checkstack/incident-common";
 import {
   autoAuthMiddleware,
@@ -12,75 +11,57 @@ import {
 import type { SignalService } from "@checkstack/signal-common";
 import type { IncidentService } from "./service";
 import { CatalogApi } from "@checkstack/catalog-common";
+import { AuthApi } from "@checkstack/auth-common";
 import type { InferClient } from "@checkstack/common";
-import { resolveRoute } from "@checkstack/common";
 import { incidentHooks } from "./hooks";
+import { notifyAffectedSystems } from "./notifications";
+import type { IncidentUpdate } from "@checkstack/incident-common";
 
 export function createRouter(
   service: IncidentService,
   signalService: SignalService,
   catalogClient: InferClient<typeof CatalogApi>,
+  authClient: InferClient<typeof AuthApi>,
   logger: Logger,
 ) {
+  /**
+   * Resolve user IDs to profile names for a list of updates.
+   * Falls back to "Unknown User" if the user cannot be found.
+   */
+  async function resolveUserNames(
+    updates: IncidentUpdate[],
+  ): Promise<IncidentUpdate[]> {
+    const userIds = [
+      ...new Set(updates.map((u) => u.createdBy).filter(Boolean)),
+    ];
+    if (userIds.length === 0) return updates;
+
+    const userMap = new Map<string, string>();
+    await Promise.all(
+      userIds.map(async (userId) => {
+        try {
+          const user = await authClient.getUserById({ userId: userId! });
+          if (user?.name) {
+            userMap.set(userId!, user.name);
+          }
+        } catch {
+          // User not found, skip
+        }
+      }),
+    );
+
+    return updates.map((update) => ({
+      ...update,
+      createdByName: update.createdBy
+        ? (userMap.get(update.createdBy) ?? undefined)
+        : undefined,
+    }));
+  }
+
   const os = implement(incidentContract)
     .$context<RpcContext>()
     .use(autoAuthMiddleware);
 
-  /**
-   * Helper to notify subscribers of affected systems about an incident event.
-   * Each system triggers a separate notification call, but within each call
-   * the subscribers are deduplicated (system + its groups).
-   */
-  const notifyAffectedSystems = async (props: {
-    incidentId: string;
-    incidentTitle: string;
-    systemIds: string[];
-    action: "created" | "updated" | "resolved";
-    severity: string;
-  }) => {
-    const { incidentId, incidentTitle, systemIds, action, severity } = props;
-
-    const actionText =
-      action === "created"
-        ? "reported"
-        : action === "resolved"
-          ? "resolved"
-          : "updated";
-
-    const importance =
-      severity === "critical"
-        ? "critical"
-        : severity === "major"
-          ? "warning"
-          : "info";
-
-    const incidentDetailPath = resolveRoute(incidentRoutes.routes.detail, {
-      incidentId,
-    });
-
-    // Deduplicate: collect unique system IDs
-    const uniqueSystemIds = [...new Set(systemIds)];
-
-    for (const systemId of uniqueSystemIds) {
-      try {
-        await catalogClient.notifySystemSubscribers({
-          systemId,
-          title: `Incident ${actionText}`,
-          body: `Incident **"${incidentTitle}"** has been ${actionText} for a system you're subscribed to.`,
-          importance: importance as "info" | "warning" | "critical",
-          action: { label: "View Incident", url: incidentDetailPath },
-          includeGroupSubscribers: true,
-        });
-      } catch (error) {
-        // Log but don't fail the operation - notifications are best-effort
-        logger.warn(
-          `Failed to notify subscribers for system ${systemId}:`,
-          error,
-        );
-      }
-    }
-  };
-
   return os.router({
     listIncidents: os.listIncidents.handler(async ({ input }) => {
       return { incidents: await service.listIncidents(input ?? {}) };
@@ -88,8 +69,13 @@ export function createRouter(
 
     getIncident: os.getIncident.handler(async ({ input }) => {
       const result = await service.getIncident(input.id);
-      // eslint-disable-next-line unicorn/no-null -- oRPC contract requires null for missing values
-      return result ?? null;
+      if (!result) {
+        // eslint-disable-next-line unicorn/no-null -- oRPC contract requires null for missing values
+        return null;
+      }
+      // Resolve user names for updates
+      const updatesWithNames = await resolveUserNames(result.updates);
+      return { ...result, updates: updatesWithNames };
     }),
 
     getIncidentsForSystem: os.getIncidentsForSystem.handler(
@@ -141,6 +127,8 @@ export function createRouter(
 
       // Send notifications to system subscribers
       await notifyAffectedSystems({
+        catalogClient,
+        logger,
         incidentId: result.id,
         incidentTitle: result.title,
         systemIds: result.systemIds,
@@ -176,6 +164,8 @@ export function createRouter(
 
       // Send notifications to system subscribers
       await notifyAffectedSystems({
+        catalogClient,
+        logger,
         incidentId: result.id,
         incidentTitle: result.title,
         systemIds: result.systemIds,
@@ -189,6 +179,13 @@ export function createRouter(
     addUpdate: os.addUpdate.handler(async ({ input, context }) => {
       const userId =
         context.user && "id" in context.user ? context.user.id : undefined;
+
+      // Get previous status before update for reopening detection
+      const previousIncident = input.statusChange
+        ? await service.getIncident(input.incidentId)
+        : undefined;
+      const previousStatus = previousIncident?.status;
+
       const result = await service.addUpdate(input, userId);
 
       // Get incident to broadcast with correct systemIds
@@ -221,6 +218,30 @@ export function createRouter(
             resolvedAt: new Date().toISOString(),
           });
         }
+
+        // Send notifications when status changes
+        if (input.statusChange && previousStatus !== input.statusChange) {
+          // Determine notification action based on status transition
+          let notificationAction: "resolved" | "reopened" | "updated";
+          if (input.statusChange === "resolved") {
+            notificationAction = "resolved";
+          } else if (previousStatus === "resolved") {
+            // Reopening: was resolved, now not resolved
+            notificationAction = "reopened";
+          } else {
+            notificationAction = "updated";
+          }
+
+          await notifyAffectedSystems({
+            catalogClient,
+            logger,
+            incidentId: input.incidentId,
+            incidentTitle: incident.title,
+            systemIds: incident.systemIds,
+            action: notificationAction,
+            severity: incident.severity,
+          });
+        }
       }
 
       return result;
@@ -256,6 +277,8 @@ export function createRouter(
 
       // Send notifications to system subscribers
       await notifyAffectedSystems({
+        catalogClient,
+        logger,
         incidentId: result.id,
         incidentTitle: result.title,
         systemIds: result.systemIds,