@checkstack/anomaly-backend 0.2.0

package/src/schema.ts

@@ -0,0 +1,87 @@
+import {
+  pgTable,
+  pgEnum,
+  text,
+  jsonb,
+  integer,
+  uuid,
+  timestamp,
+  doublePrecision,
+  unique,
+} from "drizzle-orm/pg-core";
+
+export const anomalyStateEnum = pgEnum("anomaly_state", [
+  "suspicious",
+  "anomaly",
+  "recovered",
+]);
+
+export type AnomalyState = (typeof anomalyStateEnum.enumValues)[number];
+
+export const anomalyDirectionEnum = pgEnum("anomaly_direction", [
+  "above",
+  "below",
+  "changed",
+]);
+
+export type AnomalyDirection = (typeof anomalyDirectionEnum.enumValues)[number];
+
+export const anomalyKindEnum = pgEnum("anomaly_kind", ["spike", "drift"]);
+export type AnomalyKind = (typeof anomalyKindEnum.enumValues)[number];
+
+export const anomalies = pgTable("anomalies", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  systemId: text("system_id").notNull(),
+  /**
+   * Refers to the health check configuration ID that triggered this anomaly.
+   * Together with systemId, this maps to the specific health check assignment.
+   */
+  configurationId: uuid("configuration_id").notNull(),
+  fieldPath: text("field_path").notNull(),
+  kind: anomalyKindEnum("kind").default("spike").notNull(),
+  state: anomalyStateEnum("state").notNull(),
+  direction: anomalyDirectionEnum("direction").notNull(),
+  baselineValue: doublePrecision("baseline_value"),
+  baselineStdDev: doublePrecision("baseline_std_dev"),
+  observedValue: text("observed_value").notNull(),
+  deviation: doublePrecision("deviation").notNull(),
+  suspiciousRunCount: integer("suspicious_run_count").default(0).notNull(),
+  confirmationThreshold: integer("confirmation_threshold").notNull(),
+  startedAt: timestamp("started_at").defaultNow().notNull(),
+  confirmedAt: timestamp("confirmed_at"),
+  recoveredAt: timestamp("recovered_at"),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>(),
+});
+
+export const anomalyBaselines = pgTable("anomaly_baselines", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  systemId: text("system_id").notNull(),
+  configurationId: uuid("configuration_id").notNull(),
+  fieldPath: text("field_path").notNull(),
+  mean: doublePrecision("mean").notNull(),
+  stdDev: doublePrecision("std_dev").notNull(),
+  trendSlope: doublePrecision("trend_slope").notNull(),
+  sampleCount: integer("sample_count").notNull(),
+  computedAt: timestamp("computed_at").notNull(),
+  dominantValue: text("dominant_value"),
+  dominantRatio: doublePrecision("dominant_ratio"),
+}, (t) => ({
+  uniquePath: unique("anomaly_baselines_unique_path").on(
+    t.systemId,
+    t.configurationId,
+    t.fieldPath
+  )
+}));
+
+export const anomalyConfigurations = pgTable("anomaly_configurations", {
+  configurationId: uuid("configuration_id").primaryKey(),
+  config: jsonb("config").notNull(), // VersionedRecord<AnomalySettings>
+});
+
+export const anomalyAssignments = pgTable("anomaly_assignments", {
+  systemId: text("system_id").notNull(),
+  configurationId: uuid("configuration_id").notNull(),
+  config: jsonb("config").notNull(), // VersionedRecord<Partial<AnomalySettings>>
+}, (t) => ({
+  pk: unique("anomaly_assignments_pk").on(t.systemId, t.configurationId),
+}));

package/src/service.ts

@@ -0,0 +1,163 @@
+import { eq, and, desc } from "drizzle-orm";
+import type { SafeDatabase } from "@checkstack/backend-api";
+import * as schema from "./schema";
+import { anomalySettingsConfig } from "./config";
+import type { VersionedRecord } from "@checkstack/backend-api";
+import type { AnomalySettings } from "@checkstack/anomaly-common";
+
+export class AnomalyService {
+  constructor(private readonly db: SafeDatabase<typeof schema>) {}
+
+  async getAnomalies(params: {
+    systemId?: string;
+    configurationId?: string;
+    state?: schema.AnomalyState;
+    kind?: schema.AnomalyKind;
+    limit?: number;
+  }) {
+    const conditions = [];
+
+    if (params.systemId) {
+      conditions.push(eq(schema.anomalies.systemId, params.systemId));
+    }
+    if (params.configurationId) {
+      conditions.push(
+        eq(schema.anomalies.configurationId, params.configurationId),
+      );
+    }
+    if (params.state) {
+      conditions.push(eq(schema.anomalies.state, params.state));
+    }
+    if (params.kind) {
+      conditions.push(eq(schema.anomalies.kind, params.kind));
+    }
+
+    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+
+    const results = await this.db
+      .select()
+      .from(schema.anomalies)
+      .where(whereClause)
+      .orderBy(desc(schema.anomalies.startedAt))
+      .limit(params.limit ?? 50);
+
+    return results.map((r) => ({
+      ...r,
+      startedAt: r.startedAt.toISOString(),
+      // eslint-disable-next-line unicorn/no-null
+      confirmedAt: r.confirmedAt?.toISOString() ?? null,
+      // eslint-disable-next-line unicorn/no-null
+      recoveredAt: r.recoveredAt?.toISOString() ?? null,
+    }));
+  }
+
+  async getAnomalyBaselines(params: {
+    systemId: string;
+    configurationId: string;
+  }) {
+    const results = await this.db
+      .select()
+      .from(schema.anomalyBaselines)
+      .where(
+        and(
+          eq(schema.anomalyBaselines.systemId, params.systemId),
+          eq(schema.anomalyBaselines.configurationId, params.configurationId),
+        ),
+      );
+
+    return results.map((r) => ({
+      ...r,
+      computedAt: r.computedAt.toISOString(),
+    }));
+  }
+
+  async getAnomalyConfig(
+    configurationId: string,
+  ): Promise<VersionedRecord<AnomalySettings>> {
+    const [result] = await this.db
+      .select()
+      .from(schema.anomalyConfigurations)
+      .where(eq(schema.anomalyConfigurations.configurationId, configurationId));
+
+    if (!result) {
+      // Return default configuration wrapper
+      return anomalySettingsConfig.create({
+        enabled: true,
+        sensitivity: 1,
+        confirmationWindow: 3,
+        baselineWindow: "7d",
+        notify: true,
+        driftEnabled: true,
+        driftThreshold: 2,
+      });
+    }
+
+    return result.config as VersionedRecord<AnomalySettings>;
+  }
+
+  async updateAnomalyConfig(
+    configurationId: string,
+    configData: AnomalySettings,
+  ) {
+    const newConfigRecord = anomalySettingsConfig.create(configData);
+
+    const [result] = await this.db
+      .insert(schema.anomalyConfigurations)
+      .values({
+        configurationId,
+        config: newConfigRecord,
+      })
+      .onConflictDoUpdate({
+        target: [schema.anomalyConfigurations.configurationId],
+        set: { config: newConfigRecord },
+      })
+      .returning();
+
+    return result!.config;
+  }
+
+  async getAnomalyAssignmentConfig(systemId: string, configurationId: string) {
+    const [result] = await this.db
+      .select()
+      .from(schema.anomalyAssignments)
+      .where(
+        and(
+          eq(schema.anomalyAssignments.systemId, systemId),
+          eq(schema.anomalyAssignments.configurationId, configurationId),
+        ),
+      );
+
+    return result
+      ? (result.config as VersionedRecord<Partial<AnomalySettings>>)
+      : undefined;
+  }
+
+  async updateAnomalyAssignmentConfig(
+    systemId: string,
+    configurationId: string,
+    configData: Partial<AnomalySettings>,
+  ) {
+    const newConfigRecord = {
+      version: anomalySettingsConfig.version,
+      data: configData,
+    };
+
+    const [result] = await this.db
+      .insert(schema.anomalyAssignments)
+      .values({
+        systemId,
+        configurationId,
+        config: newConfigRecord,
+      })
+      .onConflictDoUpdate({
+        target: [
+          schema.anomalyAssignments.systemId,
+          schema.anomalyAssignments.configurationId,
+        ],
+        set: { config: newConfigRecord },
+      })
+      .returning();
+
+    return result.config;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "@checkstack/tsconfig/backend.json",
+  "include": [
+    "src"
+  ]
+}