@oneuptime/common 12.0.5 → 12.0.6

package/Tests/Models/DatabaseModels/DataSourceModelSecrets.test.ts

@@ -0,0 +1,70 @@
+import DataSource from "../../../Models/DatabaseModels/DataSource";
+import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
+import Permission from "../../../Types/Permission";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * The entire mechanism keeping data source credentials out of API
+ * responses is (a) `encrypted: true` so they're ciphertext at rest and
+ * (b) `read: []` so the CRUD layer never serves the (auto-decrypted)
+ * plaintext. Decryption happens automatically on every server-side find,
+ * so a single permission added to a secret column's read list would leak
+ * plaintext credentials to that role. These tests pin both properties.
+ */
+
+const SECRET_COLUMNS: Array<string> = ["password", "apiToken", "customHeaders"];
+
+describe("DataSource model credential columns", () => {
+  const model: DataSource = new DataSource();
+  const accessControl: Record<string, ColumnAccessControl> =
+    model.getColumnAccessControlForAllColumns();
+
+  it("encrypts every secret column at rest", () => {
+    const encryptedColumns: Array<string> = model.getEncryptedColumns().columns;
+
+    for (const column of SECRET_COLUMNS) {
+      expect(encryptedColumns).toContain(column);
+    }
+  });
+
+  it("never exposes a secret column through the CRUD read path", () => {
+    for (const column of SECRET_COLUMNS) {
+      const columnAccessControl: ColumnAccessControl | undefined =
+        accessControl[column];
+      expect(columnAccessControl).toBeDefined();
+      expect(columnAccessControl!.read).toEqual([]);
+    }
+  });
+
+  it("keeps secret columns writable so users can set and rotate them", () => {
+    for (const column of SECRET_COLUMNS) {
+      const columnAccessControl: ColumnAccessControl | undefined =
+        accessControl[column];
+      expect(columnAccessControl!.create.length).toBeGreaterThan(0);
+      expect(columnAccessControl!.update.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("keeps non-secret connection columns readable for the settings UI", () => {
+    for (const column of [
+      "name",
+      "dataSourceType",
+      "url",
+      "databaseHost",
+      "databasePort",
+      "databaseName",
+      "username",
+    ]) {
+      const columnAccessControl: ColumnAccessControl | undefined =
+        accessControl[column];
+      expect(columnAccessControl).toBeDefined();
+      expect(columnAccessControl!.read).toContain(Permission.ReadDataSource);
+    }
+  });
+
+  it("lets project viewers read the table so dashboards render for them", () => {
+    const tableReadPermissions: Array<Permission> = model.getReadPermissions();
+    expect(tableReadPermissions).toContain(Permission.Viewer);
+    expect(tableReadPermissions).toContain(Permission.ProjectMember);
+  });
+});

package/Tests/Server/API/AIInvestigationAPI.test.ts

@@ -69,6 +69,7 @@ function investigationRun(data: {
   status: AIRunStatus;
   createdAt?: Date | undefined;
   completedAt?: Date | undefined;
+  analysisTldr?: string | undefined;
 }): AIRun {
   const run: AIRun = new AIRun(
     new ObjectID("eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee"),
@@ -80,6 +81,9 @@ function investigationRun(data: {
   if (data.completedAt) {
     run.completedAt = data.completedAt;
   }
+  if (data.analysisTldr !== undefined) {
+    run.analysisTldr = data.analysisTldr;
+  }
   return run;
 }
 
@@ -154,6 +158,7 @@ describe("AIInvestigationAPI latest-investigation payload", () => {
       run: null,
       events: [],
       analysisMarkdown: null,
+      analysisTldr: null,
       isAnalysisPending: false,
     });
     expect(PostedRootCause.getForInvestigation).not.toHaveBeenCalled();
@@ -212,6 +217,188 @@ describe("AIInvestigationAPI latest-investigation payload", () => {
     );
   });
 
+  /*
+   * The TL;DR summarizes the report, so the payload must never carry one
+   * without the report it describes — a reader would otherwise see a claim
+   * with nothing to check it against.
+   */
+  it("returns the stored TL;DR alongside a published report", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Completed,
+        createdAt: new Date("2026-08-07T09:55:00.000Z"),
+        completedAt: new Date("2026-08-07T10:00:00.000Z"),
+        analysisTldr: "The checkout API is failing on an exhausted pool.",
+      }),
+      analysisMarkdown: "## Current investigation\nPool exhausted.",
+    });
+
+    expect(sentPayload()).toEqual(
+      expect.objectContaining({
+        analysisTldr: "The checkout API is failing on an exhausted pool.",
+      }),
+    );
+  });
+
+  /*
+   * The column is selected, so it also travels inside the serialized run.
+   * Both copies must obey the same gate — otherwise a client reading
+   * run.analysisTldr shows a summary of a report the payload does not carry.
+   */
+  it("applies the report gate to the serialized run as well as the top-level field", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Completed,
+        createdAt: new Date("2026-08-07T10:00:00.000Z"),
+        completedAt: new Date(Date.now() - 1000),
+        analysisTldr: "The checkout API is failing on an exhausted pool.",
+      }),
+    });
+
+    const payload: JSONObject = sentPayload();
+    expect(payload["analysisTldr"]).toBeNull();
+    expect((payload["run"] as JSONObject)["analysisTldr"]).toBeNull();
+  });
+
+  it("carries the same TL;DR in the run and at the top level once the report exists", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Completed,
+        createdAt: new Date("2026-08-07T09:55:00.000Z"),
+        completedAt: new Date("2026-08-07T10:00:00.000Z"),
+        analysisTldr: "The checkout API is failing on an exhausted pool.",
+      }),
+      analysisMarkdown: "## Current investigation\nPool exhausted.",
+    });
+
+    const payload: JSONObject = sentPayload();
+    expect(payload["analysisTldr"]).toBe(
+      "The checkout API is failing on an exhausted pool.",
+    );
+    expect((payload["run"] as JSONObject)["analysisTldr"]).toBe(
+      payload["analysisTldr"],
+    );
+  });
+
+  it("normalizes the run's blank TL;DR to null too", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Completed,
+        createdAt: new Date("2026-08-07T09:55:00.000Z"),
+        completedAt: new Date("2026-08-07T10:00:00.000Z"),
+        analysisTldr: "   ",
+      }),
+      analysisMarkdown: "## Current investigation\nPool exhausted.",
+    });
+
+    expect((sentPayload()["run"] as JSONObject)["analysisTldr"]).toBeNull();
+  });
+
+  /*
+   * The route always returns the LATEST run, while the report is bound to
+   * that run's id. A re-investigation therefore replaces both — and must not
+   * leave the previous run's summary on screen describing an analysis the
+   * payload no longer carries.
+   */
+  it("never shows a previous run's summary once a new run supersedes it", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Running,
+        createdAt: new Date("2026-08-07T11:00:00.000Z"),
+      }),
+    });
+
+    const payload: JSONObject = sentPayload();
+    expect(payload["analysisMarkdown"]).toBeNull();
+    expect(payload["analysisTldr"]).toBeNull();
+    expect((payload["run"] as JSONObject)["analysisTldr"]).toBeNull();
+  });
+
+  it("selects the TL;DR column so a live panel can render it", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Completed,
+        createdAt: new Date("2026-08-07T09:55:00.000Z"),
+        completedAt: new Date("2026-08-07T10:00:00.000Z"),
+      }),
+      analysisMarkdown: "## Current investigation\nPool exhausted.",
+    });
+
+    expect(AIRunService.findBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        select: expect.objectContaining({ analysisTldr: true }),
+      }),
+    );
+  });
+
+  it("withholds the TL;DR while the report is still being published", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Completed,
+        createdAt: new Date("2026-08-07T10:00:00.000Z"),
+        completedAt: new Date(Date.now() - 1000),
+        analysisTldr: "The checkout API is failing on an exhausted pool.",
+      }),
+    });
+
+    expect(sentPayload()).toEqual(
+      expect.objectContaining({
+        analysisMarkdown: null,
+        analysisTldr: null,
+        isAnalysisPending: true,
+      }),
+    );
+  });
+
+  it("normalizes a blank stored TL;DR to null so the panel has one empty shape", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Completed,
+        createdAt: new Date("2026-08-07T09:55:00.000Z"),
+        completedAt: new Date("2026-08-07T10:00:00.000Z"),
+        analysisTldr: "   \n  ",
+      }),
+      analysisMarkdown: "## Current investigation\nPool exhausted.",
+    });
+
+    expect(sentPayload()).toEqual(
+      expect.objectContaining({ analysisTldr: null }),
+    );
+  });
+
+  it("reports no TL;DR for a legacy run that predates the column", async () => {
+    await callIncidentRoute({
+      run: investigationRun({
+        status: AIRunStatus.Completed,
+        createdAt: new Date("2026-08-07T09:55:00.000Z"),
+        completedAt: new Date("2026-08-07T10:00:00.000Z"),
+      }),
+      analysisMarkdown: "## Current investigation\nPool exhausted.",
+    });
+
+    expect(sentPayload()).toEqual(
+      expect.objectContaining({ analysisTldr: null }),
+    );
+  });
+
+  it.each([AIRunStatus.Running, AIRunStatus.Error])(
+    "never reports a TL;DR for a %s run",
+    async (status: AIRunStatus) => {
+      await callIncidentRoute({
+        run: investigationRun({
+          status,
+          createdAt: new Date("2026-08-07T09:55:00.000Z"),
+          completedAt: new Date("2026-08-07T10:00:00.000Z"),
+          analysisTldr: "The checkout API is failing on an exhausted pool.",
+        }),
+      });
+
+      expect(sentPayload()).toEqual(
+        expect.objectContaining({ analysisTldr: null }),
+      );
+    },
+  );
+
   it("returns a branded pre-migration report through the null-associated legacy path", async () => {
     const run: AIRun = investigationRun({
       status: AIRunStatus.Completed,