@oneuptime/common 12.0.0 → 12.0.2

package/Server/Types/Database/QueryHelper.ts

@@ -7,6 +7,7 @@ import Typeof from "../../../Types/Typeof";
 import { FindOperator, Raw } from "typeorm";
 import { FindWhereProperty } from "../../../Types/BaseDatabase/Query";
 import CaptureSpan from "../../Utils/Telemetry/CaptureSpan";
+import buildJSONColumnQuery, { JSONColumnQuery } from "./JSONColumnQuery";
 
 export default class QueryHelper {
   @CaptureSpan()
@@ -668,40 +669,25 @@ export default class QueryHelper {
     ) as FindWhereProperty<any>;
   }
 
+  /**
+   * Filter on the keys of a jsonb column — `customFields` above all, whose
+   * keys are the names a project gave its custom fields.
+   *
+   * The per-key predicates (equality, "is any of", contains, numeric
+   * comparison, is-empty, and their negations) live in JSONColumnQuery. Two
+   * things this used to get wrong and no longer does: the key was spliced
+   * straight into the SQL string, and every value was compared with `=`, so an
+   * operator such as `Includes` reached Postgres stringified.
+   */
   @CaptureSpan()
   public static queryJson(value: JSONObject): FindWhereProperty<any> {
-    // seed random text
-    const values: JSONObject = {};
-
-    let queryText: string = "";
-
-    if (typeof value === Typeof.String) {
-      value = JSON.parse(value.toString());
-    }
-
     if (value instanceof FindOperator) {
       return value;
     }
 
-    const hasValue: boolean = value && Object.keys(value).length > 0;
-
-    for (const key in value) {
-      const temp: string = Text.generateRandomText(10);
-
-      values[temp] = value[key];
-
-      if (!queryText) {
-        queryText = `(COLUMN_NAME_ALIAS->>'${key}' = :${temp as string}`;
-      } else {
-        queryText += ` AND COLUMN_NAME_ALIAS->>'${key}' = :${temp as string}`;
-      }
-    }
-
-    if (hasValue) {
-      queryText += ")";
-    } else {
-      queryText = "(COLUMN_NAME_ALIAS IS NULL OR COLUMN_NAME_ALIAS = '{}')";
-    }
+    const jsonQuery: JSONColumnQuery = buildJSONColumnQuery({
+      value: value as JSONObject,
+    });
 
     return Raw((alias: string) => {
       /*
@@ -709,16 +695,15 @@ export default class QueryHelper {
        * we need to convert this to "tableName"."columnName"
        */
 
-      alias = alias
+      const columnReference: string = alias
         .split(".")
         .map((item: string) => {
           return `"${item}"`;
         })
         .join(".");
 
-      queryText = Text.replaceAll(queryText, "COLUMN_NAME_ALIAS", `${alias}`);
-      return queryText;
-    }, values);
+      return jsonQuery.toSql(columnReference);
+    }, jsonQuery.parameters);
   }
 
   @CaptureSpan()

package/Server/Utils/Database/TruncateColumnValue.ts

@@ -0,0 +1,84 @@
+import ColumnLength from "../../../Types/Database/ColumnLength";
+
+/*
+ * ------------------------------------------------------------------
+ * TruncateColumnValue
+ *
+ * Per-value clamps for bounded varchar columns written by the bulk
+ * inventory upsert paths (Kubernetes / Docker / Docker Swarm / Podman /
+ * Proxmox / Ceph / IoT).
+ *
+ * Those services hand-build `INSERT ... ON CONFLICT` statements and
+ * flush them in chunks of 500 rows through
+ * `getRepository().manager.query(...)`, which bypasses the length
+ * validation DatabaseService applies to ordinary CRUD writes. A single
+ * value past its column limit raises 22001 ("value too long for type
+ * character varying(N)") and aborts the WHOLE multi-row INSERT, so one
+ * malformed resource silently drops up to 499 healthy inventory rows
+ * with it. Clamping per value keeps the blast radius at one field.
+ *
+ * Truncation is the last line of defense, not the primary fix: columns
+ * that legitimately carry long values (image references, Kubernetes
+ * DNS-subdomain names) should be widened in the model + a migration so
+ * these clamps effectively never fire.
+ * ------------------------------------------------------------------
+ */
+
+export function truncateToLength(value: string, maxLength: number): string;
+export function truncateToLength(
+  value: string | null | undefined,
+  maxLength: number,
+): string | null;
+export function truncateToLength(
+  value: string | null | undefined,
+  maxLength: number,
+): string | null {
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  const clipped: string = value.substring(0, maxLength);
+
+  /*
+   * JS string length counts UTF-16 code units, so a cut at maxLength can
+   * land in the middle of a surrogate pair (any astral-plane character:
+   * emoji, rare CJK). The orphaned high surrogate is not valid UTF-8 —
+   * Node encodes it as U+FFFD on the way to the driver — so drop it.
+   * A well-formed string never ends a character on a high surrogate,
+   * which makes this check unambiguous. Postgres counts characters, not
+   * code units, so clipping by code units is always conservative: the
+   * result can only be shorter than the column bound, never longer.
+   */
+  const lastCodeUnit: number = clipped.charCodeAt(clipped.length - 1);
+  if (lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff) {
+    return clipped.substring(0, clipped.length - 1);
+  }
+
+  return clipped;
+}
+
+/** Clamp to ColumnLength.ShortText — varchar(100). */
+export function truncateShortText(value: string): string;
+export function truncateShortText(
+  value: string | null | undefined,
+): string | null;
+export function truncateShortText(
+  value: string | null | undefined,
+): string | null {
+  return truncateToLength(value, ColumnLength.ShortText);
+}
+
+/** Clamp to ColumnLength.LongText — varchar(500). */
+export function truncateLongText(value: string): string;
+export function truncateLongText(
+  value: string | null | undefined,
+): string | null;
+export function truncateLongText(
+  value: string | null | undefined,
+): string | null {
+  return truncateToLength(value, ColumnLength.LongText);
+}

package/Server/Utils/Monitor/Criteria/CompareCriteria.ts

@@ -192,6 +192,18 @@ export default class CompareCriteria {
       return null;
     }
 
+    /*
+     * parseInt("abc") returns NaN rather than throwing, and NaN is typeof
+     * "number" — so without this guard a non-numeric threshold would leak
+     * past callers that only check for `=== null`, leaving every numeric
+     * comparison silently false (value > NaN is always false). Treat an
+     * unparseable value the same as a missing one so the caller can ignore
+     * it instead of firing a broken criterion.
+     */
+    if (Number.isNaN(threshold as number)) {
+      return null;
+    }
+
     return threshold as number;
   }
 

package/Tests/App/Dashboard/RunnerInstallInstructions.test.tsx

@@ -0,0 +1,119 @@
+import "@testing-library/jest-dom";
+import { render, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, test } from "@jest/globals";
+import RunnerInstallInstructions from "../../../../App/FeatureSet/Dashboard/src/Components/Runner/InstallInstructions";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * The setup card renders the docker run command with the Runner's secret key
+ * embedded in it. Reading that key is restricted to Project Owner, Project
+ * Admin and Runbook Admin (see the ColumnAccessControl on Runner.key), so for
+ * a Member or a Viewer the field simply is not in the API response.
+ *
+ * The Runners table asked for the key and passed `(item.key as string) || ""`
+ * straight through, so those users were handed a command ending in
+ * ONEUPTIME_RUNNER_KEY= with nothing after it — which copies cleanly, runs on
+ * the host, and fails there with an authentication error. These tests pin that
+ * no command is ever rendered without a key.
+ */
+
+const RUNNER_ID: ObjectID = new ObjectID("abc-123");
+
+type RenderWithKeyFunction = (key: string) => HTMLElement;
+
+const renderWithKey: RenderWithKeyFunction = (key: string): HTMLElement => {
+  const { container } = render(
+    <RunnerInstallInstructions runnerId={RUNNER_ID} runnerKey={key} />,
+  );
+
+  return container;
+};
+
+describe("RunnerInstallInstructions", () => {
+  describe("when the key is readable", () => {
+    test("renders the docker run command", () => {
+      const container: HTMLElement = renderWithKey("super-secret-key");
+
+      expect(container.textContent).toContain("docker run");
+      expect(container.textContent).toContain("oneuptime/runner:release");
+    });
+
+    test("embeds the Runner id and key", () => {
+      const container: HTMLElement = renderWithKey("super-secret-key");
+
+      expect(container.textContent).toContain("ONEUPTIME_RUNNER_ID=abc-123");
+      expect(container.textContent).toContain(
+        "ONEUPTIME_RUNNER_KEY=super-secret-key",
+      );
+    });
+
+    test("does not render the permission warning", () => {
+      renderWithKey("super-secret-key");
+
+      expect(
+        screen.queryByText(/do not have permission/i),
+      ).not.toBeInTheDocument();
+    });
+
+    /*
+     * The container needs outbound HTTPS only; saying so here is what stops
+     * someone opening an inbound hole for it.
+     */
+    test("states that the Runner needs no inbound connections", () => {
+      const container: HTMLElement = renderWithKey("super-secret-key");
+
+      expect(container.textContent).toContain(
+        "does not accept inbound connections",
+      );
+    });
+
+    /*
+     * Added because "I ran the command and it still says Never connected" is
+     * the obvious next confusion once the never-connected state exists.
+     */
+    test("explains that the first heartbeat takes up to a minute", () => {
+      const container: HTMLElement = renderWithKey("super-secret-key");
+
+      expect(container.textContent).toContain("every 60 seconds");
+      expect(container.textContent).toContain("Connected");
+    });
+  });
+
+  describe("when the key is not readable", () => {
+    test("renders the permission warning instead", () => {
+      renderWithKey("");
+
+      expect(
+        screen.getByText(
+          "You do not have permission to view this Runner's key",
+        ),
+      ).toBeInTheDocument();
+    });
+
+    /*
+     * The load-bearing assertion: no command at all, rather than a command
+     * that is silently broken.
+     */
+    test("renders no docker command at all", () => {
+      const container: HTMLElement = renderWithKey("");
+
+      expect(container.textContent).not.toContain("docker run");
+      expect(container.textContent).not.toContain("ONEUPTIME_RUNNER_KEY");
+    });
+
+    test("never emits an empty ONEUPTIME_RUNNER_KEY=", () => {
+      const container: HTMLElement = renderWithKey("");
+
+      expect(container.textContent).not.toMatch(/ONEUPTIME_RUNNER_KEY=\s/);
+    });
+
+    test("says who can supply the command", () => {
+      const container: HTMLElement = renderWithKey("");
+
+      expect(container.textContent).toContain("Project Owner");
+      expect(container.textContent).toContain("Project Admin");
+      expect(container.textContent).toContain("Runbook Admin");
+    });
+  });
+});

package/Tests/App/Dashboard/RunnerStatus.test.tsx

@@ -0,0 +1,274 @@
+import "@testing-library/jest-dom";
+import { render, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, test } from "@jest/globals";
+import RunnerStatusElement from "../../../../App/FeatureSet/Dashboard/src/Components/Runner/RunnerStatus";
+import Runner, {
+  RunnerConnectionStatus,
+} from "../../../Models/DatabaseModels/Runner";
+import OneUptimeDate from "../../../Types/Date";
+import { JSONObject } from "../../../Types/JSON";
+
+/*
+ * The one component every Runner connection indicator in the dashboard now
+ * renders through. Three call sites used to hand-roll this, and all three read
+ * the persisted connectionStatus column — which is written on create and on
+ * the first heartbeat and never again. A Runner that died months ago still has
+ * it set to "connected".
+ *
+ * So the assertions that matter most here are the ones proving the rendered
+ * status tracks lastAlive and IGNORES connectionStatus, in both directions.
+ */
+
+type RenderRunnerFunction = (
+  runner: Runner | JSONObject,
+  showLastSeen?: boolean,
+) => void;
+
+const renderRunner: RenderRunnerFunction = (
+  runner: Runner | JSONObject,
+  showLastSeen?: boolean,
+): void => {
+  render(
+    showLastSeen === undefined ? (
+      <RunnerStatusElement runner={runner} />
+    ) : (
+      <RunnerStatusElement runner={runner} showLastSeen={showLastSeen} />
+    ),
+  );
+};
+
+type MinutesAgoFunction = (minutes: number) => Date;
+
+const minutesAgo: MinutesAgoFunction = (minutes: number): Date => {
+  return OneUptimeDate.getSomeMinutesAgo(minutes);
+};
+
+type StatusTextFunction = () => string;
+
+/*
+ * Statusbubble renders role="status" with aria-label "Status: <text>", so the
+ * accessible name is the assertion surface — it is what a screen reader
+ * announces, not just what happens to be in a div.
+ */
+const statusText: StatusTextFunction = (): string => {
+  return screen.getByRole("status").getAttribute("aria-label") || "";
+};
+
+describe("RunnerStatusElement", () => {
+  describe("never connected", () => {
+    test("a Runner with no lastAlive reads 'Never connected'", () => {
+      renderRunner({ lastAlive: null });
+
+      expect(screen.getByText("Never connected")).toBeInTheDocument();
+      expect(statusText()).toBe("Status: Never connected");
+    });
+
+    test("a Runner with lastAlive absent entirely reads 'Never connected'", () => {
+      renderRunner({});
+
+      expect(screen.getByText("Never connected")).toBeInTheDocument();
+    });
+
+    /*
+     * The whole point of the third state. A Runner created ten seconds ago
+     * whose container has not been started is not a failure, and must not be
+     * dressed as one — it used to render the same red "Disconnected" as a
+     * Runner that crashed in production.
+     */
+    test("it is not called Disconnected", () => {
+      renderRunner({ lastAlive: null });
+
+      expect(screen.queryByText("Disconnected")).not.toBeInTheDocument();
+      expect(statusText()).not.toContain("Disconnected");
+    });
+
+    test("it is grey, not red", () => {
+      const { container } = render(
+        <RunnerStatusElement runner={{ lastAlive: null }} />,
+      );
+
+      const html: string = container.innerHTML;
+
+      // Gray500 #6b7280, Red #fd625e.
+      expect(html).toContain("107, 114, 128");
+      expect(html).not.toContain("253, 98, 94");
+    });
+
+    test("it does not animate", () => {
+      const { container } = render(
+        <RunnerStatusElement runner={{ lastAlive: null }} />,
+      );
+
+      expect(container.innerHTML).not.toContain("animate-ping");
+    });
+  });
+
+  describe("connected", () => {
+    test("a heartbeat right now reads 'Connected'", () => {
+      renderRunner({ lastAlive: OneUptimeDate.getCurrentDate() });
+
+      expect(screen.getByText("Connected")).toBeInTheDocument();
+      expect(statusText()).toBe("Status: Connected");
+    });
+
+    test("a heartbeat four minutes ago still reads 'Connected'", () => {
+      renderRunner({ lastAlive: minutesAgo(4) });
+
+      expect(screen.getByText("Connected")).toBeInTheDocument();
+    });
+
+    test("it is green and animating", () => {
+      const { container } = render(
+        <RunnerStatusElement
+          runner={{ lastAlive: OneUptimeDate.getCurrentDate() }}
+        />,
+      );
+
+      // Green #2ab57d.
+      expect(container.innerHTML).toContain("42, 181, 125");
+      expect(container.innerHTML).toContain("animate-ping");
+    });
+  });
+
+  describe("disconnected", () => {
+    test("a heartbeat an hour ago reads 'Disconnected'", () => {
+      renderRunner({ lastAlive: minutesAgo(60) });
+
+      expect(statusText()).toContain("Disconnected");
+    });
+
+    /*
+     * "How long has it been gone" is the entire question when a Runner drops,
+     * and the detail card has no other column carrying it.
+     */
+    test("it appends how long ago the last heartbeat was", () => {
+      renderRunner({ lastAlive: minutesAgo(60) });
+
+      expect(statusText()).toBe("Status: Disconnected · an hour ago");
+    });
+
+    test("a day-old heartbeat says a day ago", () => {
+      renderRunner({ lastAlive: minutesAgo(60 * 24) });
+
+      expect(statusText()).toBe("Status: Disconnected · a day ago");
+    });
+
+    /*
+     * In the Runners table a Last Seen column sits directly beside this one,
+     * so repeating the relative time would be noise.
+     */
+    test("showLastSeen={false} suppresses the relative time", () => {
+      renderRunner({ lastAlive: minutesAgo(60) }, false);
+
+      expect(statusText()).toBe("Status: Disconnected");
+    });
+
+    test("showLastSeen={true} is the same as the default", () => {
+      renderRunner({ lastAlive: minutesAgo(60) }, true);
+
+      expect(statusText()).toBe("Status: Disconnected · an hour ago");
+    });
+
+    test("it is red and does not animate", () => {
+      const { container } = render(
+        <RunnerStatusElement runner={{ lastAlive: minutesAgo(60) }} />,
+      );
+
+      // Red #fd625e.
+      expect(container.innerHTML).toContain("253, 98, 94");
+      expect(container.innerHTML).not.toContain("animate-ping");
+    });
+  });
+
+  /*
+   * The regression suite. Each of these is a shape the old inline
+   * implementations got wrong.
+   */
+  describe("connectionStatus is ignored", () => {
+    test("stale lastAlive reads Disconnected even when connectionStatus says Connected", () => {
+      renderRunner({
+        connectionStatus: RunnerConnectionStatus.Connected,
+        lastAlive: minutesAgo(60 * 24 * 90),
+      });
+
+      expect(statusText()).toContain("Disconnected");
+      expect(screen.queryByText("Connected")).not.toBeInTheDocument();
+    });
+
+    test("fresh lastAlive reads Connected even when connectionStatus says Disconnected", () => {
+      renderRunner({
+        connectionStatus: RunnerConnectionStatus.Disconnected,
+        lastAlive: OneUptimeDate.getCurrentDate(),
+      });
+
+      expect(statusText()).toBe("Status: Connected");
+    });
+
+    /*
+     * Exactly what RunnerService.onBeforeCreate produces: connectionStatus
+     * defaulted to Disconnected, lastAlive still null. The user has not
+     * failed at anything yet — they have not run the Docker command.
+     */
+    test("a freshly created Runner reads Never connected, not Disconnected", () => {
+      renderRunner({
+        connectionStatus: RunnerConnectionStatus.Disconnected,
+        lastAlive: null,
+      });
+
+      expect(statusText()).toBe("Status: Never connected");
+    });
+
+    test("connectionStatus alone never produces a Connected bubble", () => {
+      renderRunner({ connectionStatus: RunnerConnectionStatus.Connected });
+
+      expect(statusText()).toBe("Status: Never connected");
+    });
+  });
+
+  describe("input shapes", () => {
+    /*
+     * The table hands over a hydrated model; ModelDetail's getElement hands
+     * over the same. The API layer hands over a plain object with an ISO
+     * string. All three have to work.
+     */
+    test("accepts a hydrated Runner model", () => {
+      const runner: Runner = new Runner();
+      runner.lastAlive = OneUptimeDate.getCurrentDate();
+
+      renderRunner(runner);
+
+      expect(statusText()).toBe("Status: Connected");
+    });
+
+    test("accepts a hydrated Runner model that never connected", () => {
+      renderRunner(new Runner());
+
+      expect(statusText()).toBe("Status: Never connected");
+    });
+
+    test("accepts an ISO string lastAlive", () => {
+      renderRunner({ lastAlive: new Date().toISOString() });
+
+      expect(statusText()).toBe("Status: Connected");
+    });
+
+    test("accepts a stale ISO string lastAlive", () => {
+      renderRunner({ lastAlive: minutesAgo(60).toISOString() });
+
+      expect(statusText()).toContain("Disconnected");
+    });
+
+    /*
+     * An unparseable timestamp must not be rendered as a healthy Runner. It
+     * falls to Disconnected, and the appended relative time is suppressed
+     * rather than printed as "Invalid date".
+     */
+    test("an unparseable lastAlive is Disconnected and prints no garbage time", () => {
+      renderRunner({ lastAlive: "not-a-date" });
+
+      expect(statusText()).toContain("Disconnected");
+      expect(statusText()).not.toContain("Invalid");
+    });
+  });
+});