@checkstack/incident-backend 1.8.1 → 1.8.3

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # @checkstack/incident-backend
 
+## 1.8.3
+
+### Patch Changes
+
+- 8cad340: refactor: typed router-factory args and structured logging
+
+  Internal router factories that took long positional argument lists
+  (`incident-backend`, `maintenance-backend`, and `notification-backend`'s
+  `createNotificationRouter`) now take a single typed `deps` object, matching the
+  `RouterDeps` convention already used by sibling routers and removing a class of
+  easy-to-transpose call sites.
+
+  Backend code paths that wrote to `console.*` now use the injected structured
+  `Logger` so they respect log levels and correlation: the catalog router's
+  notification-resource lifecycle warnings, the notification OAuth callback
+  handler's errors, and the command router's search-provider failures. The
+  command router factory now takes a typed `{ logger }` object.
+
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+- Updated dependencies [8cad340]
+  - @checkstack/ai-backend@0.8.0
+  - @checkstack/ai-common@0.6.0
+  - @checkstack/automation-backend@0.9.3
+  - @checkstack/status-page-backend@0.3.0
+  - @checkstack/backend-api@0.25.0
+  - @checkstack/notification-common@1.4.0
+  - @checkstack/common@0.17.0
+  - @checkstack/auth-common@0.11.0
+  - @checkstack/integration-backend@0.6.5
+  - @checkstack/command-backend@0.2.12
+  - @checkstack/catalog-backend@1.5.3
+  - @checkstack/status-page-common@0.3.0
+  - @checkstack/catalog-common@2.4.2
+  - @checkstack/incident-common@1.6.2
+  - @checkstack/automation-common@0.7.1
+  - @checkstack/cache-api@0.3.14
+  - @checkstack/integration-common@0.9.2
+  - @checkstack/signal-common@0.2.11
+  - @checkstack/cache-utils@0.2.19
+
+## 1.8.2
+
+### Patch Changes
+
+- Updated dependencies [2ec8f64]
+  - @checkstack/backend-api@0.24.1
+  - @checkstack/catalog-backend@1.5.2
+  - @checkstack/automation-backend@0.9.2
+  - @checkstack/ai-backend@0.7.2
+  - @checkstack/command-backend@0.2.11
+  - @checkstack/integration-backend@0.6.4
+  - @checkstack/status-page-backend@0.2.1
+
 ## 1.8.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/incident-backend",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "license": "Elastic-2.0",
   "type": "module",
   "main": "src/index.ts",
@@ -14,34 +14,34 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/ai-backend": "0.7.1",
-    "@checkstack/ai-common": "0.5.0",
-    "@checkstack/backend-api": "0.24.0",
-    "@checkstack/cache-api": "0.3.13",
-    "@checkstack/cache-utils": "0.2.18",
-    "@checkstack/incident-common": "1.6.1",
-    "@checkstack/catalog-common": "2.4.1",
-    "@checkstack/catalog-backend": "1.5.1",
-    "@checkstack/notification-common": "1.3.4",
-    "@checkstack/auth-common": "0.10.0",
-    "@checkstack/command-backend": "0.2.10",
-    "@checkstack/signal-common": "0.2.10",
-    "@checkstack/status-page-backend": "0.2.0",
-    "@checkstack/status-page-common": "0.2.0",
-    "@checkstack/integration-backend": "0.6.3",
-    "@checkstack/integration-common": "0.9.1",
-    "@checkstack/automation-backend": "0.9.1",
-    "@checkstack/automation-common": "0.7.0",
-    "@checkstack/common": "0.16.0",
+    "@checkstack/ai-backend": "0.8.0",
+    "@checkstack/ai-common": "0.6.0",
+    "@checkstack/backend-api": "0.25.0",
+    "@checkstack/cache-api": "0.3.14",
+    "@checkstack/cache-utils": "0.2.19",
+    "@checkstack/incident-common": "1.6.2",
+    "@checkstack/catalog-common": "2.4.2",
+    "@checkstack/catalog-backend": "1.5.3",
+    "@checkstack/notification-common": "1.4.0",
+    "@checkstack/auth-common": "0.11.0",
+    "@checkstack/command-backend": "0.2.12",
+    "@checkstack/signal-common": "0.2.11",
+    "@checkstack/status-page-backend": "0.3.0",
+    "@checkstack/status-page-common": "0.3.0",
+    "@checkstack/integration-backend": "0.6.5",
+    "@checkstack/integration-common": "0.9.2",
+    "@checkstack/automation-backend": "0.9.3",
+    "@checkstack/automation-common": "0.7.1",
+    "@checkstack/common": "0.17.0",
     "drizzle-orm": "^0.45.0",
     "zod": "^4.2.1",
     "@orpc/contract": "^1.14.4",
     "@orpc/server": "^1.14.4"
   },
   "devDependencies": {
-    "@checkstack/drizzle-helper": "0.0.5",
-    "@checkstack/scripts": "0.6.2",
-    "@checkstack/test-utils-backend": "0.1.44",
+    "@checkstack/drizzle-helper": "0.0.6",
+    "@checkstack/scripts": "0.6.3",
+    "@checkstack/test-utils-backend": "0.1.46",
     "@checkstack/tsconfig": "0.0.7",
     "@types/bun": "^1.0.0",
     "drizzle-kit": "^0.31.10",

package/src/cache.test.ts

@@ -0,0 +1,229 @@
+import { describe, test, expect, mock } from "bun:test";
+import type {
+  CacheManager,
+  CacheProvider,
+} from "@checkstack/cache-api";
+import type { Logger } from "@checkstack/backend-api";
+import type {
+  IncidentDetail,
+  IncidentWithSystems,
+} from "@checkstack/incident-common";
+import { createIncidentCache, type IncidentCache } from "./cache";
+
+// Loader signatures derived from the cache's own surface, so the fakes match
+// the real `IncidentService` return types without re-declaring those shapes.
+type IncidentLoader = Parameters<IncidentCache["wrapIncident"]>[1];
+type ListLoader = Parameters<IncidentCache["wrapList"]>[1];
+type SystemLoader = Parameters<IncidentCache["wrapSystem"]>[1];
+
+const sampleIncident: IncidentDetail = {
+  id: "i1",
+  title: "DB down",
+  status: "investigating",
+  severity: "major",
+  suppressNotifications: false,
+  createdAt: new Date("2026-06-01T00:00:00Z"),
+  updatedAt: new Date("2026-06-01T00:00:00Z"),
+  systemIds: ["s1"],
+  updates: [],
+  links: [],
+};
+
+const sampleWithSystems: IncidentWithSystems = {
+  id: sampleIncident.id,
+  title: sampleIncident.title,
+  status: sampleIncident.status,
+  severity: sampleIncident.severity,
+  suppressNotifications: sampleIncident.suppressNotifications,
+  createdAt: sampleIncident.createdAt,
+  updatedAt: sampleIncident.updatedAt,
+  systemIds: sampleIncident.systemIds,
+};
+
+// Loaders return non-undefined values so the read-through cache actually
+// stores them (the scope treats `undefined` as a miss).
+const incidentLoaderReturning: IncidentLoader = async () => sampleIncident;
+const listLoaderReturning: ListLoader = async () => [sampleWithSystems];
+const systemLoaderReturning: SystemLoader = async () => [sampleWithSystems];
+
+function createMemoryProvider(): {
+  provider: CacheProvider;
+  store: Map<string, unknown>;
+} {
+  const store = new Map<string, unknown>();
+  const provider: CacheProvider = {
+    get: async <T>(key: string) => store.get(key) as T | undefined,
+    set: async (key, value) => {
+      store.set(key, value);
+    },
+    delete: async (key) => {
+      store.delete(key);
+    },
+    deleteByPrefix: async (prefix) => {
+      let removed = 0;
+      for (const key of [...store.keys()]) {
+        if (key.startsWith(prefix)) {
+          store.delete(key);
+          removed++;
+        }
+      }
+      return removed;
+    },
+    has: async (key) => store.has(key),
+  };
+  return { provider, store };
+}
+
+function createManager(provider: CacheProvider): CacheManager {
+  return {
+    getProvider: () => provider,
+    getActivePlugin: () => "incident",
+    getActiveConfig: () => ({}),
+    setActiveBackend: async () => {},
+    shutdown: async () => {},
+  };
+}
+
+const noopLogger: Logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+} as unknown as Logger;
+
+function makeCache() {
+  const { provider, store } = createMemoryProvider();
+  const cache = createIncidentCache({
+    cacheManager: createManager(provider),
+    logger: noopLogger,
+  });
+  return { cache, store };
+}
+
+describe("incident cache — read-through wrapping", () => {
+  test("wrapIncident caches per id and only calls the loader once for a hit", async () => {
+    const { cache } = makeCache();
+    const loader = mock(incidentLoaderReturning);
+
+    const a = await cache.wrapIncident("i1", loader);
+    const b = await cache.wrapIncident("i1", loader);
+
+    expect(a).toEqual(sampleIncident);
+    expect(b).toEqual(sampleIncident);
+    // Second read is served from cache: the loader ran only once.
+    expect(loader).toHaveBeenCalledTimes(1);
+  });
+
+  test("wrapList keys by filter shape — different filters do not share a slot", async () => {
+    const { cache } = makeCache();
+    const loaderA = mock(listLoaderReturning);
+    const loaderB = mock(listLoaderReturning);
+
+    const resA = await cache.wrapList({ status: "open" }, loaderA);
+    const resB = await cache.wrapList({ status: "resolved" }, loaderB);
+
+    expect(resA).toEqual([sampleWithSystems]);
+    expect(resB).toEqual([sampleWithSystems]);
+    expect(loaderA).toHaveBeenCalledTimes(1);
+    expect(loaderB).toHaveBeenCalledTimes(1);
+  });
+
+  test("wrapList collapses key-order-different but equal filter shapes to one slot", async () => {
+    const { cache } = makeCache();
+    const loader = mock(listLoaderReturning);
+
+    await cache.wrapList({ a: 1, b: 2 }, loader);
+    // Same logical filter, keys in a different order -> same cache key.
+    const second = await cache.wrapList({ b: 2, a: 1 }, loader);
+
+    expect(second).toEqual([sampleWithSystems]);
+    expect(loader).toHaveBeenCalledTimes(1);
+  });
+
+  test("wrapList treats undefined filters and {} as the same slot", async () => {
+    const { cache } = makeCache();
+    const loader = mock(listLoaderReturning);
+
+    await cache.wrapList(undefined, loader);
+    await cache.wrapList({}, loader);
+
+    expect(loader).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("incident cache — invalidation fan-out", () => {
+  test("invalidateForMutation drops the incident, its systems, and all list shapes", async () => {
+    const { cache } = makeCache();
+    const incidentLoader = mock(incidentLoaderReturning);
+    const systemLoader = mock(systemLoaderReturning);
+    const listLoader = mock(listLoaderReturning);
+
+    await cache.wrapIncident("i1", incidentLoader);
+    await cache.wrapSystem("s1", systemLoader);
+    await cache.wrapList({ status: "open" }, listLoader);
+
+    await cache.invalidateForMutation({ incidentId: "i1", systemIds: ["s1"] });
+
+    // All three must re-load on next read.
+    await cache.wrapIncident("i1", incidentLoader);
+    await cache.wrapSystem("s1", systemLoader);
+    await cache.wrapList({ status: "open" }, listLoader);
+
+    expect(incidentLoader).toHaveBeenCalledTimes(2);
+    expect(systemLoader).toHaveBeenCalledTimes(2);
+    expect(listLoader).toHaveBeenCalledTimes(2);
+  });
+
+  test("invalidateForMutation does NOT touch an unrelated incident's cache", async () => {
+    const { cache } = makeCache();
+    const otherLoader = mock(incidentLoaderReturning);
+
+    await cache.wrapIncident("i2", otherLoader);
+    await cache.invalidateForMutation({ incidentId: "i1", systemIds: ["s1"] });
+    await cache.wrapIncident("i2", otherLoader);
+
+    expect(otherLoader).toHaveBeenCalledTimes(1);
+  });
+
+  test("invalidateForMutation drops every affected system in one call", async () => {
+    const { cache } = makeCache();
+    const s1 = mock(systemLoaderReturning);
+    const s2 = mock(systemLoaderReturning);
+
+    await cache.wrapSystem("s1", s1);
+    await cache.wrapSystem("s2", s2);
+
+    await cache.invalidateForMutation({
+      incidentId: "i1",
+      systemIds: ["s1", "s2"],
+    });
+
+    await cache.wrapSystem("s1", s1);
+    await cache.wrapSystem("s2", s2);
+
+    expect(s1).toHaveBeenCalledTimes(2);
+    expect(s2).toHaveBeenCalledTimes(2);
+  });
+
+  test("invalidateSystem drops one system's cache plus all lists, leaving incidents alone", async () => {
+    const { cache } = makeCache();
+    const systemLoader = mock(systemLoaderReturning);
+    const listLoader = mock(listLoaderReturning);
+    const incidentLoader = mock(incidentLoaderReturning);
+
+    await cache.wrapSystem("s1", systemLoader);
+    await cache.wrapList({}, listLoader);
+    await cache.wrapIncident("i1", incidentLoader);
+
+    await cache.invalidateSystem("s1");
+
+    await cache.wrapSystem("s1", systemLoader);
+    await cache.wrapList({}, listLoader);
+    await cache.wrapIncident("i1", incidentLoader);
+
+    expect(systemLoader).toHaveBeenCalledTimes(2);
+    expect(listLoader).toHaveBeenCalledTimes(2);
+    // The incident entry survives a system-only invalidation.
+    expect(incidentLoader).toHaveBeenCalledTimes(1);
+  });
+});

package/src/index.ts

@@ -195,7 +195,7 @@ export default createBackendPlugin({
 
         const cache = createIncidentCache({ cacheManager, logger });
         incidentCache = cache;
-        const router = createRouter(
+        const router = createRouter({
           service,
           signalService,
           catalogClient,
@@ -203,8 +203,8 @@ export default createBackendPlugin({
           authClient,
           logger,
           cache,
-          () => incidentEntity,
-        );
+          getIncidentEntity: () => incidentEntity,
+        });
         rpc.registerRouter(router, incidentContract);
 
         // Register incident actions with the Automation platform. We

package/src/router.ts

@@ -28,19 +28,30 @@ import {
   type IncidentEntityState,
 } from "./incident-entity";
 
-export function createRouter(
-  service: IncidentService,
-  signalService: SignalService,
-  catalogClient: InferClient<typeof CatalogApi>,
+export interface IncidentRouterDeps {
+  service: IncidentService;
+  signalService: SignalService;
+  catalogClient: InferClient<typeof CatalogApi>;
   notificationClient: InferClient<
     typeof import("@checkstack/notification-common").NotificationApi
-  >,
-  authClient: InferClient<typeof AuthApi>,
-  logger: Logger,
-  cache: IncidentCache,
+  >;
+  authClient: InferClient<typeof AuthApi>;
+  logger: Logger;
+  cache: IncidentCache;
   /** Resolver for the reactive `incident` entity (§10.1). Undefined in tests. */
-  getIncidentEntity?: () => EntityHandle<IncidentEntityState> | undefined,
-) {
+  getIncidentEntity?: () => EntityHandle<IncidentEntityState> | undefined;
+}
+
+export function createRouter({
+  service,
+  signalService,
+  catalogClient,
+  notificationClient,
+  authClient,
+  logger,
+  cache,
+  getIncidentEntity,
+}: IncidentRouterDeps) {
   /**
    * Resolve user IDs to profile names for a list of updates.
    * Falls back to "Unknown User" if the user cannot be found.