@checkstack/healthcheck-backend 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @checkstack/healthcheck-backend
 
+## 0.4.2
+
+### Patch Changes
+
+- 66a3963: Fix 500 error on `getDetailedAggregatedHistory` and update to SafeDatabase type
+
+  - Fixed runtime error caused by usage of Drizzle relational query API (`db.query`) in `getAggregatedHistory`
+  - Replaced `db.query.healthCheckConfigurations.findFirst()` with standard `db.select()` query
+  - Updated all database type declarations from `NodePgDatabase` to `SafeDatabase`
+
+- Updated dependencies [2c0822d]
+- Updated dependencies [66a3963]
+- Updated dependencies [66a3963]
+- Updated dependencies [66a3963]
+  - @checkstack/queue-api@0.2.0
+  - @checkstack/catalog-backend@0.2.7
+  - @checkstack/integration-backend@0.1.6
+  - @checkstack/backend-api@0.5.0
+  - @checkstack/command-backend@0.1.6
+
+## 0.4.1
+
+### Patch Changes
+
+- Updated dependencies [8a87cd4]
+- Updated dependencies [8a87cd4]
+- Updated dependencies [8a87cd4]
+- Updated dependencies [8a87cd4]
+- Updated dependencies [8a87cd4]
+  - @checkstack/backend-api@0.4.1
+  - @checkstack/catalog-common@1.2.3
+  - @checkstack/common@0.5.0
+  - @checkstack/healthcheck-common@0.4.2
+  - @checkstack/maintenance-common@0.4.1
+  - @checkstack/catalog-backend@0.2.6
+  - @checkstack/command-backend@0.1.5
+  - @checkstack/integration-backend@0.1.5
+  - @checkstack/queue-api@0.1.3
+  - @checkstack/signal-common@0.1.3
+
 ## 0.4.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-backend",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {

package/src/aggregation.test.ts

@@ -6,25 +6,27 @@ describe("HealthCheckService.getAggregatedHistory", () => {
   let mockDb: ReturnType<typeof createMockDb>;
   let mockRegistry: ReturnType<typeof createMockRegistry>;
   let service: HealthCheckService;
+  // Store mock data for different queries
+  let mockConfigResult: { id: string; strategyId: string } | null = null;
+  let mockRunsResult: unknown[] = [];
 
   function createMockDb() {
-    return {
-      select: mock(() => ({
-        from: mock(() => ({
-          where: mock(() => ({
-            orderBy: mock(() => Promise.resolve([])),
-          })),
+    // Create a mock that handles both config queries (with limit) and runs queries (with orderBy)
+    const createSelectChain = () => ({
+      from: mock(() => ({
+        where: mock(() => ({
+          // For config query: uses .limit(1)
+          limit: mock(() =>
+            Promise.resolve(mockConfigResult ? [mockConfigResult] : []),
+          ),
+          // For runs query: uses .orderBy()
+          orderBy: mock(() => Promise.resolve(mockRunsResult)),
         })),
       })),
-      query: {
-        healthCheckConfigurations: {
-          findFirst: mock(() => Promise.resolve(null)) as ReturnType<
-            typeof mock<
-              () => Promise<{ id: string; strategyId: string } | null>
-            >
-          >,
-        },
-      },
+    });
+
+    return {
+      select: mock(createSelectChain),
     };
   }
 
@@ -47,6 +49,9 @@ describe("HealthCheckService.getAggregatedHistory", () => {
   }
 
   beforeEach(() => {
+    // Reset mock data
+    mockConfigResult = null;
+    mockRunsResult = [];
     mockDb = createMockDb();
     mockRegistry = createMockRegistry();
     service = new HealthCheckService(mockDb as never, mockRegistry as never);
@@ -65,7 +70,7 @@ describe("HealthCheckService.getAggregatedHistory", () => {
           endDate,
           bucketSize: "auto",
         },
-        { includeAggregatedResult: true }
+        { includeAggregatedResult: true },
       );
 
       expect(result.buckets).toEqual([]);
@@ -83,7 +88,7 @@ describe("HealthCheckService.getAggregatedHistory", () => {
           endDate,
           bucketSize: "auto",
         },
-        { includeAggregatedResult: true }
+        { includeAggregatedResult: true },
       );
 
       expect(result.buckets).toEqual([]);
@@ -122,18 +127,9 @@ describe("HealthCheckService.getAggregatedHistory", () => {
         },
       ];
 
-      // Setup mock to return runs
-      mockDb.select = mock(() => ({
-        from: mock(() => ({
-          where: mock(() => ({
-            orderBy: mock(() => Promise.resolve(runs)),
-          })),
-        })),
-      }));
-
-      mockDb.query.healthCheckConfigurations.findFirst = mock(() =>
-        Promise.resolve({ id: "config-1", strategyId: "http" })
-      );
+      // Setup mock data
+      mockRunsResult = runs;
+      mockConfigResult = { id: "config-1", strategyId: "http" };
 
       const result = await service.getAggregatedHistory(
         {
@@ -143,14 +139,14 @@ describe("HealthCheckService.getAggregatedHistory", () => {
           endDate: new Date("2024-01-01T23:59:59Z"),
           bucketSize: "hourly",
         },
-        { includeAggregatedResult: true }
+        { includeAggregatedResult: true },
       );
 
       expect(result.buckets).toHaveLength(2);
 
       // First bucket (10:00)
       const bucket10 = result.buckets.find(
-        (b) => b.bucketStart.getHours() === 10
+        (b) => b.bucketStart.getHours() === 10,
       );
       expect(bucket10).toBeDefined();
       expect(bucket10!.runCount).toBe(2);
@@ -161,7 +157,7 @@ describe("HealthCheckService.getAggregatedHistory", () => {
 
       // Second bucket (11:00)
       const bucket11 = result.buckets.find(
-        (b) => b.bucketStart.getHours() === 11
+        (b) => b.bucketStart.getHours() === 11,
       );
       expect(bucket11).toBeDefined();
       expect(bucket11!.runCount).toBe(1);
@@ -182,17 +178,9 @@ describe("HealthCheckService.getAggregatedHistory", () => {
         timestamp: new Date("2024-01-01T10:00:00Z"),
       }));
 
-      mockDb.select = mock(() => ({
-        from: mock(() => ({
-          where: mock(() => ({
-            orderBy: mock(() => Promise.resolve(runs)),
-          })),
-        })),
-      }));
-
-      mockDb.query.healthCheckConfigurations.findFirst = mock(() =>
-        Promise.resolve({ id: "config-1", strategyId: "http" })
-      );
+      // Setup mock data
+      mockRunsResult = runs;
+      mockConfigResult = { id: "config-1", strategyId: "http" };
 
       const result = await service.getAggregatedHistory(
         {
@@ -202,7 +190,7 @@ describe("HealthCheckService.getAggregatedHistory", () => {
           endDate: new Date("2024-01-01T23:59:59Z"),
           bucketSize: "hourly",
         },
-        { includeAggregatedResult: true }
+        { includeAggregatedResult: true },
       );
 
       expect(result.buckets).toHaveLength(1);
@@ -224,17 +212,9 @@ describe("HealthCheckService.getAggregatedHistory", () => {
         },
       ];
 
-      mockDb.select = mock(() => ({
-        from: mock(() => ({
-          where: mock(() => ({
-            orderBy: mock(() => Promise.resolve(runs)),
-          })),
-        })),
-      }));
-
-      mockDb.query.healthCheckConfigurations.findFirst = mock(() =>
-        Promise.resolve({ id: "config-1", strategyId: "http" })
-      );
+      // Setup mock data
+      mockRunsResult = runs;
+      mockConfigResult = { id: "config-1", strategyId: "http" };
 
       const result = await service.getAggregatedHistory(
         {
@@ -244,7 +224,7 @@ describe("HealthCheckService.getAggregatedHistory", () => {
           endDate: new Date("2024-01-01T23:59:59Z"),
           bucketSize: "hourly",
         },
-        { includeAggregatedResult: true }
+        { includeAggregatedResult: true },
       );
 
       const bucket = result.buckets[0];
@@ -270,18 +250,9 @@ describe("HealthCheckService.getAggregatedHistory", () => {
         },
       ];
 
-      mockDb.select = mock(() => ({
-        from: mock(() => ({
-          where: mock(() => ({
-            orderBy: mock(() => Promise.resolve(runs)),
-          })),
-        })),
-      }));
-
-      // No config found means no strategy
-      mockDb.query.healthCheckConfigurations.findFirst = mock(() =>
-        Promise.resolve(null)
-      );
+      // Setup mock data - no config found means no strategy
+      mockRunsResult = runs;
+      mockConfigResult = null;
 
       const result = await service.getAggregatedHistory(
         {
@@ -291,12 +262,12 @@ describe("HealthCheckService.getAggregatedHistory", () => {
           endDate: new Date("2024-01-01T23:59:59Z"),
           bucketSize: "hourly",
         },
-        { includeAggregatedResult: true }
+        { includeAggregatedResult: true },
       );
 
       const bucket = result.buckets[0];
       expect(
-        "aggregatedResult" in bucket ? bucket.aggregatedResult : undefined
+        "aggregatedResult" in bucket ? bucket.aggregatedResult : undefined,
       ).toBeUndefined();
     });
   });
@@ -333,17 +304,9 @@ describe("HealthCheckService.getAggregatedHistory", () => {
         },
       ];
 
-      mockDb.select = mock(() => ({
-        from: mock(() => ({
-          where: mock(() => ({
-            orderBy: mock(() => Promise.resolve(runs)),
-          })),
-        })),
-      }));
-
-      mockDb.query.healthCheckConfigurations.findFirst = mock(() =>
-        Promise.resolve({ id: "config-1", strategyId: "http" })
-      );
+      // Setup mock data
+      mockRunsResult = runs;
+      mockConfigResult = { id: "config-1", strategyId: "http" };
 
       const result = await service.getAggregatedHistory(
         {
@@ -353,7 +316,7 @@ describe("HealthCheckService.getAggregatedHistory", () => {
           endDate: new Date("2024-01-03T00:00:00Z"),
           bucketSize: "daily",
         },
-        { includeAggregatedResult: true }
+        { includeAggregatedResult: true },
       );
 
       expect(result.buckets).toHaveLength(2);

package/src/index.ts

@@ -3,7 +3,6 @@ import {
   bootstrapHealthChecks,
 } from "./queue-executor";
 import * as schema from "./schema";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import {
   healthCheckAccessRules,
   healthCheckAccess,
@@ -15,6 +14,7 @@ import {
   createBackendPlugin,
   coreServices,
   type EmitHookFn,
+  type SafeDatabase,
 } from "@checkstack/backend-api";
 import { integrationEventExtensionPoint } from "@checkstack/integration-backend";
 import { z } from "zod";
@@ -130,7 +130,7 @@ export default createBackendPlugin({
         });
 
         const healthCheckRouter = createHealthCheckRouter(
-          database as NodePgDatabase<typeof schema>,
+          database as SafeDatabase<typeof schema>,
           healthCheckRegistry,
         );
         rpc.registerRouter(healthCheckRouter, healthCheckContract);

package/src/queue-executor.ts

@@ -4,6 +4,7 @@ import {
   type EmitHookFn,
   type CollectorRegistry,
   evaluateAssertions,
+  type SafeDatabase,
 } from "@checkstack/backend-api";
 import { QueueManager } from "@checkstack/queue-api";
 import {
@@ -13,7 +14,6 @@ import {
 } from "./schema";
 import * as schema from "./schema";
 import { eq, and, max } from "drizzle-orm";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { type SignalService } from "@checkstack/signal-common";
 import {
   HEALTH_CHECK_RUN_COMPLETED,
@@ -25,7 +25,7 @@ import { resolveRoute, type InferClient } from "@checkstack/common";
 import { HealthCheckService } from "./service";
 import { healthCheckHooks } from "./hooks";
 
-type Db = NodePgDatabase<typeof schema>;
+type Db = SafeDatabase<typeof schema>;
 type CatalogClient = InferClient<typeof CatalogApi>;
 type MaintenanceClient = InferClient<typeof MaintenanceApi>;
 

package/src/retention-job.ts

@@ -1,19 +1,20 @@
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  HealthCheckRegistry,
+  Logger,
+  SafeDatabase,
+} from "@checkstack/backend-api";
 import * as schema from "./schema";
 import {
   healthCheckRuns,
   systemHealthChecks,
   healthCheckAggregates,
+  healthCheckConfigurations,
   DEFAULT_RETENTION_CONFIG,
 } from "./schema";
 import { eq, and, lt, sql } from "drizzle-orm";
-import type {
-  HealthCheckRegistry,
-  Logger,
-} from "@checkstack/backend-api";
 import type { QueueManager } from "@checkstack/queue-api";
 
-type Db = NodePgDatabase<typeof schema>;
+type Db = SafeDatabase<typeof schema>;
 
 interface RetentionJobDeps {
   db: Db;
@@ -46,7 +47,7 @@ export async function setupRetentionJob(deps: RetentionJobDeps) {
       await runRetentionJob({ db, registry, logger, queueManager });
       logger.info("Completed health check retention job");
     },
-    { consumerGroup: "retention-worker" }
+    { consumerGroup: "retention-worker" },
   );
 
   // Schedule daily retention run (86400 seconds = 24 hours)
@@ -55,7 +56,7 @@ export async function setupRetentionJob(deps: RetentionJobDeps) {
     {
       jobId: "health-check-retention-daily",
       intervalSeconds: 24 * 60 * 60, // Daily (24 hours)
-    }
+    },
   );
 
   logger.info("Health check retention job scheduled (runs daily)");
@@ -102,7 +103,7 @@ export async function runRetentionJob(deps: RetentionJobDeps) {
     } catch (error) {
       logger.error(
         `Retention job failed for ${assignment.systemId}/${assignment.configurationId}`,
-        { error }
+        { error },
       );
     }
   }
@@ -127,9 +128,11 @@ async function aggregateRawRuns(params: AggregateRawRunsParams) {
   cutoffDate.setHours(cutoffDate.getHours(), 0, 0, 0); // Round to hour
 
   // Get strategy for metadata aggregation
-  const config = await db.query.healthCheckConfigurations.findFirst({
-    where: eq(schema.healthCheckConfigurations.id, configurationId),
-  });
+  const [config] = await db
+    .select()
+    .from(healthCheckConfigurations)
+    .where(eq(healthCheckConfigurations.id, configurationId))
+    .limit(1);
   const strategy = config ? registry.getStrategy(config.strategyId) : undefined;
 
   // Query raw runs older than cutoff, grouped by hour
@@ -140,8 +143,8 @@ async function aggregateRawRuns(params: AggregateRawRunsParams) {
       and(
         eq(healthCheckRuns.systemId, systemId),
         eq(healthCheckRuns.configurationId, configurationId),
-        lt(healthCheckRuns.timestamp, cutoffDate)
-      )
+        lt(healthCheckRuns.timestamp, cutoffDate),
+      ),
     )
     .orderBy(healthCheckRuns.timestamp);
 
@@ -284,8 +287,8 @@ async function rollupHourlyAggregates(params: RollupParams) {
         eq(healthCheckAggregates.systemId, systemId),
         eq(healthCheckAggregates.configurationId, configurationId),
         eq(healthCheckAggregates.bucketSize, "hourly"),
-        lt(healthCheckAggregates.bucketStart, cutoffDate)
-      )
+        lt(healthCheckAggregates.bucketStart, cutoffDate),
+      ),
     );
 
   if (oldHourly.length === 0) return;
@@ -392,8 +395,8 @@ async function deleteExpiredAggregates(params: DeleteExpiredParams) {
         eq(healthCheckAggregates.systemId, systemId),
         eq(healthCheckAggregates.configurationId, configurationId),
         eq(healthCheckAggregates.bucketSize, "daily"),
-        lt(healthCheckAggregates.bucketStart, cutoffDate)
-      )
+        lt(healthCheckAggregates.bucketStart, cutoffDate),
+      ),
     );
 }
 

package/src/router.ts

@@ -4,10 +4,10 @@ import {
   toJsonSchema,
   type RpcContext,
   type HealthCheckRegistry,
+  type SafeDatabase,
 } from "@checkstack/backend-api";
 import { healthCheckContract } from "@checkstack/healthcheck-common";
 import { HealthCheckService } from "./service";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import * as schema from "./schema";
 import { toJsonSchemaWithChartMeta } from "./schema-utils";
 
@@ -18,8 +18,8 @@ import { toJsonSchemaWithChartMeta } from "./schema-utils";
  * based on the contract's meta.userType and meta.access.
  */
 export const createHealthCheckRouter = (
-  database: NodePgDatabase<typeof schema>,
-  registry: HealthCheckRegistry
+  database: SafeDatabase<typeof schema>,
+  registry: HealthCheckRegistry,
 ) => {
   // Create service instance once - shared across all handlers
   const service = new HealthCheckService(database, registry);
@@ -40,7 +40,7 @@ export const createHealthCheckRouter = (
           ? toJsonSchemaWithChartMeta(r.strategy.result.schema)
           : undefined,
         aggregatedResultSchema: toJsonSchemaWithChartMeta(
-          r.strategy.aggregatedResult.schema
+          r.strategy.aggregatedResult.schema,
         ),
       }));
     }),
@@ -48,7 +48,7 @@ export const createHealthCheckRouter = (
     getCollectors: os.getCollectors.handler(async ({ input, context }) => {
       // Get strategy to verify it exists
       const strategy = context.healthCheckRegistry.getStrategy(
-        input.strategyId
+        input.strategyId,
       );
       if (!strategy) {
         return [];
@@ -103,13 +103,13 @@ export const createHealthCheckRouter = (
     getSystemConfigurations: os.getSystemConfigurations.handler(
       async ({ input }) => {
         return service.getSystemConfigurations(input);
-      }
+      },
     ),
 
     getSystemAssociations: os.getSystemAssociations.handler(
       async ({ input }) => {
         return service.getSystemAssociations(input.systemId);
-      }
+      },
     ),
 
     associateSystem: os.associateSystem.handler(async ({ input, context }) => {
@@ -123,7 +123,7 @@ export const createHealthCheckRouter = (
       // If enabling the health check, schedule it immediately
       if (input.body.enabled) {
         const config = await service.getConfiguration(
-          input.body.configurationId
+          input.body.configurationId,
         );
         if (config) {
           const { scheduleHealthCheck } = await import("./queue-executor");
@@ -152,9 +152,9 @@ export const createHealthCheckRouter = (
         await service.updateRetentionConfig(
           input.systemId,
           input.configurationId,
-          input.retentionConfig
+          input.retentionConfig,
         );
-      }
+      },
     ),
 
     getHistory: os.getHistory.handler(async ({ input }) => {
@@ -176,12 +176,12 @@ export const createHealthCheckRouter = (
         return service.getAggregatedHistory(input, {
           includeAggregatedResult: true,
         });
-      }
+      },
     ),
     getSystemHealthStatus: os.getSystemHealthStatus.handler(
       async ({ input }) => {
         return service.getSystemHealthStatus(input.systemId);
-      }
+      },
     ),
 
     getBulkSystemHealthStatus: os.getBulkSystemHealthStatus.handler(
@@ -195,17 +195,17 @@ export const createHealthCheckRouter = (
         await Promise.all(
           input.systemIds.map(async (systemId) => {
             statuses[systemId] = await service.getSystemHealthStatus(systemId);
-          })
+          }),
         );
 
         return { statuses };
-      }
+      },
     ),
 
     getSystemHealthOverview: os.getSystemHealthOverview.handler(
       async ({ input }) => {
         return service.getSystemHealthOverview(input.systemId);
-      }
+      },
     ),
   });
 };

package/src/service.ts

@@ -14,14 +14,16 @@ import {
 } from "./schema";
 import * as schema from "./schema";
 import { eq, and, InferSelectModel, desc, gte, lte } from "drizzle-orm";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { ORPCError } from "@orpc/server";
 import { evaluateHealthStatus } from "./state-evaluator";
 import { stateThresholds } from "./state-thresholds-migrations";
-import type { HealthCheckRegistry } from "@checkstack/backend-api";
+import type {
+  HealthCheckRegistry,
+  SafeDatabase,
+} from "@checkstack/backend-api";
 
-// Drizzle type helper
-type Db = NodePgDatabase<typeof schema>;
+// Drizzle type helper - uses SafeDatabase to prevent relational query API usage
+type Db = SafeDatabase<typeof schema>;
 
 interface SystemCheckStatus {
   configurationId: string;
@@ -38,10 +40,13 @@ interface SystemHealthStatusResponse {
 }
 
 export class HealthCheckService {
-  constructor(private db: Db, private registry?: HealthCheckRegistry) {}
+  constructor(
+    private db: Db,
+    private registry?: HealthCheckRegistry,
+  ) {}
 
   async createConfiguration(
-    data: CreateHealthCheckConfiguration
+    data: CreateHealthCheckConfiguration,
   ): Promise<HealthCheckConfiguration> {
     const [config] = await this.db
       .insert(healthCheckConfigurations)
@@ -58,7 +63,7 @@ export class HealthCheckService {
   }
 
   async getConfiguration(
-    id: string
+    id: string,
   ): Promise<HealthCheckConfiguration | undefined> {
     const [config] = await this.db
       .select()
@@ -69,7 +74,7 @@ export class HealthCheckService {
 
   async updateConfiguration(
     id: string,
-    data: UpdateHealthCheckConfiguration
+    data: UpdateHealthCheckConfiguration,
   ): Promise<HealthCheckConfiguration | undefined> {
     const [config] = await this.db
       .update(healthCheckConfigurations)
@@ -137,8 +142,8 @@ export class HealthCheckService {
       .where(
         and(
           eq(systemHealthChecks.systemId, systemId),
-          eq(systemHealthChecks.configurationId, configurationId)
-        )
+          eq(systemHealthChecks.configurationId, configurationId),
+        ),
       );
   }
 
@@ -147,7 +152,7 @@ export class HealthCheckService {
    */
   async getRetentionConfig(
     systemId: string,
-    configurationId: string
+    configurationId: string,
   ): Promise<{ retentionConfig: RetentionConfig | null }> {
     const row = await this.db
       .select({ retentionConfig: systemHealthChecks.retentionConfig })
@@ -155,8 +160,8 @@ export class HealthCheckService {
       .where(
         and(
           eq(systemHealthChecks.systemId, systemId),
-          eq(systemHealthChecks.configurationId, configurationId)
-        )
+          eq(systemHealthChecks.configurationId, configurationId),
+        ),
       )
       .then((rows) => rows[0]);
 
@@ -170,7 +175,7 @@ export class HealthCheckService {
   async updateRetentionConfig(
     systemId: string,
     configurationId: string,
-    retentionConfig: RetentionConfig | null
+    retentionConfig: RetentionConfig | null,
   ): Promise<void> {
     // Validate retention hierarchy: raw < hourly < daily
     if (retentionConfig) {
@@ -197,8 +202,8 @@ export class HealthCheckService {
       .where(
         and(
           eq(systemHealthChecks.systemId, systemId),
-          eq(systemHealthChecks.configurationId, configurationId)
-        )
+          eq(systemHealthChecks.configurationId, configurationId),
+        ),
       );
   }
 
@@ -213,7 +218,7 @@ export class HealthCheckService {
   }
 
   async getSystemConfigurations(
-    systemId: string
+    systemId: string,
   ): Promise<HealthCheckConfiguration[]> {
     const rows = await this.db
       .select({
@@ -222,7 +227,7 @@ export class HealthCheckService {
       .from(systemHealthChecks)
       .innerJoin(
         healthCheckConfigurations,
-        eq(systemHealthChecks.configurationId, healthCheckConfigurations.id)
+        eq(systemHealthChecks.configurationId, healthCheckConfigurations.id),
       )
       .where(eq(systemHealthChecks.systemId, systemId));
 
@@ -243,7 +248,7 @@ export class HealthCheckService {
       .from(systemHealthChecks)
       .innerJoin(
         healthCheckConfigurations,
-        eq(systemHealthChecks.configurationId, healthCheckConfigurations.id)
+        eq(systemHealthChecks.configurationId, healthCheckConfigurations.id),
       )
       .where(eq(systemHealthChecks.systemId, systemId));
 
@@ -269,7 +274,7 @@ export class HealthCheckService {
    * Aggregates status from all health check configurations for this system.
    */
   async getSystemHealthStatus(
-    systemId: string
+    systemId: string,
   ): Promise<SystemHealthStatusResponse> {
     // Get all associations for this system with their thresholds and config names
     const associations = await this.db
@@ -282,13 +287,13 @@ export class HealthCheckService {
       .from(systemHealthChecks)
       .innerJoin(
         healthCheckConfigurations,
-        eq(systemHealthChecks.configurationId, healthCheckConfigurations.id)
+        eq(systemHealthChecks.configurationId, healthCheckConfigurations.id),
       )
       .where(
         and(
           eq(systemHealthChecks.systemId, systemId),
-          eq(systemHealthChecks.enabled, true)
-        )
+          eq(systemHealthChecks.enabled, true),
+        ),
       );
 
     if (associations.length === 0) {
@@ -314,8 +319,8 @@ export class HealthCheckService {
         .where(
           and(
             eq(healthCheckRuns.systemId, systemId),
-            eq(healthCheckRuns.configurationId, assoc.configurationId)
-          )
+            eq(healthCheckRuns.configurationId, assoc.configurationId),
+          ),
         )
         .orderBy(desc(healthCheckRuns.timestamp))
         .limit(maxWindowSize);
@@ -375,7 +380,7 @@ export class HealthCheckService {
       .from(systemHealthChecks)
       .innerJoin(
         healthCheckConfigurations,
-        eq(systemHealthChecks.configurationId, healthCheckConfigurations.id)
+        eq(systemHealthChecks.configurationId, healthCheckConfigurations.id),
       )
       .where(eq(systemHealthChecks.systemId, systemId));
 
@@ -394,8 +399,8 @@ export class HealthCheckService {
         .where(
           and(
             eq(healthCheckRuns.systemId, systemId),
-            eq(healthCheckRuns.configurationId, assoc.configurationId)
-          )
+            eq(healthCheckRuns.configurationId, assoc.configurationId),
+          ),
         )
         .orderBy(desc(healthCheckRuns.timestamp))
         .limit(sparklineLimit);
@@ -558,7 +563,7 @@ export class HealthCheckService {
       endDate: Date;
       bucketSize: "hourly" | "daily" | "auto";
     },
-    options: { includeAggregatedResult: boolean }
+    options: { includeAggregatedResult: boolean },
   ) {
     const { systemId, configurationId, startDate, endDate } = props;
     let bucketSize = props.bucketSize;
@@ -571,9 +576,13 @@ export class HealthCheckService {
     }
 
     // Get the configuration to find the strategy
-    const config = await this.db.query.healthCheckConfigurations.findFirst({
-      where: eq(healthCheckConfigurations.id, configurationId),
-    });
+    // Note: Using standard select instead of relational query API
+    // as the relational API is blocked by the scoped database proxy
+    const [config] = await this.db
+      .select()
+      .from(healthCheckConfigurations)
+      .where(eq(healthCheckConfigurations.id, configurationId))
+      .limit(1);
 
     // Look up strategy for aggregateResult function (only if needed)
     const strategy =
@@ -590,8 +599,8 @@ export class HealthCheckService {
           eq(healthCheckRuns.systemId, systemId),
           eq(healthCheckRuns.configurationId, configurationId),
           gte(healthCheckRuns.timestamp, startDate),
-          lte(healthCheckRuns.timestamp, endDate)
-        )
+          lte(healthCheckRuns.timestamp, endDate),
+        ),
       )
       .orderBy(healthCheckRuns.timestamp);
 
@@ -631,13 +640,13 @@ export class HealthCheckService {
     const buckets = [...bucketMap.values()].map((bucket) => {
       const runCount = bucket.runs.length;
       const healthyCount = bucket.runs.filter(
-        (r) => r.status === "healthy"
+        (r) => r.status === "healthy",
       ).length;
       const degradedCount = bucket.runs.filter(
-        (r) => r.status === "degraded"
+        (r) => r.status === "degraded",
       ).length;
       const unhealthyCount = bucket.runs.filter(
-        (r) => r.status === "unhealthy"
+        (r) => r.status === "unhealthy",
       ).length;
       const successRate = runCount > 0 ? healthyCount / runCount : 0;
 
@@ -691,7 +700,7 @@ export class HealthCheckService {
 
   private getBucketStart(
     timestamp: Date,
-    bucketSize: "hourly" | "daily"
+    bucketSize: "hourly" | "daily",
   ): Date {
     const date = new Date(timestamp);
     if (bucketSize === "daily") {
@@ -709,7 +718,7 @@ export class HealthCheckService {
   }
 
   private mapConfig(
-    row: InferSelectModel<typeof healthCheckConfigurations>
+    row: InferSelectModel<typeof healthCheckConfigurations>,
   ): HealthCheckConfiguration {
     return {
       id: row.id,