@oneuptime/common 12.0.0 → 12.0.2

package/Tests/Server/Utils/AI/ToolArgsExtractors.test.ts

@@ -0,0 +1,141 @@
+import { ToolArgs } from "../../../../Server/Utils/AI/Toolbox/ToolTypes";
+import { JSONObject } from "../../../../Types/JSON";
+import ObjectID from "../../../../Types/ObjectID";
+
+/*
+ * ToolArgs.scopeServiceIds and getTimeRange already have dedicated suites.
+ * This covers the remaining argument extractors — the coercion, trimming,
+ * clamping and defaulting rules the AI toolbox relies on to turn loosely-typed
+ * model-supplied JSON arguments into safe, typed values.
+ */
+
+describe("ToolArgs extractors", () => {
+  describe("getString", () => {
+    test("trims and returns a non-empty string", () => {
+      expect(ToolArgs.getString({ q: "  hello  " }, "q")).toBe("hello");
+    });
+
+    test("returns undefined for empty or whitespace-only strings", () => {
+      expect(ToolArgs.getString({ q: "" }, "q")).toBeUndefined();
+      expect(ToolArgs.getString({ q: "   " }, "q")).toBeUndefined();
+    });
+
+    test("returns undefined for missing keys and non-string values", () => {
+      expect(ToolArgs.getString({}, "q")).toBeUndefined();
+      expect(ToolArgs.getString({ q: 5 }, "q")).toBeUndefined();
+      expect(ToolArgs.getString({ q: null }, "q")).toBeUndefined();
+      expect(ToolArgs.getString({ q: ["a"] }, "q")).toBeUndefined();
+    });
+  });
+
+  describe("getStringArray", () => {
+    test("keeps only non-empty strings, trimming them", () => {
+      expect(
+        ToolArgs.getStringArray({ ids: ["a", " b ", "", "  ", "c"] }, "ids"),
+      ).toEqual(["a", " b ", "c"]);
+    });
+
+    test("filters out non-string members", () => {
+      expect(
+        ToolArgs.getStringArray(
+          { ids: ["a", 1, true, null, "b"] as unknown as Array<string> },
+          "ids",
+        ),
+      ).toEqual(["a", "b"]);
+    });
+
+    test("returns undefined when nothing survives filtering", () => {
+      expect(
+        ToolArgs.getStringArray({ ids: ["", "   "] }, "ids"),
+      ).toBeUndefined();
+      expect(ToolArgs.getStringArray({ ids: [] }, "ids")).toBeUndefined();
+    });
+
+    test("returns undefined for a non-array value", () => {
+      expect(ToolArgs.getStringArray({ ids: "a,b" }, "ids")).toBeUndefined();
+      expect(ToolArgs.getStringArray({}, "ids")).toBeUndefined();
+    });
+  });
+
+  describe("getNumber", () => {
+    const options: { defaultValue: number; min: number; max: number } = {
+      defaultValue: 10,
+      min: 1,
+      max: 100,
+    };
+
+    test("passes finite numbers through, flooring fractionals", () => {
+      expect(ToolArgs.getNumber({ n: 5 }, "n", options)).toBe(5);
+      expect(ToolArgs.getNumber({ n: 5.9 }, "n", options)).toBe(5);
+    });
+
+    test("parses numeric strings", () => {
+      expect(ToolArgs.getNumber({ n: "7" }, "n", options)).toBe(7);
+      expect(ToolArgs.getNumber({ n: "7.8" }, "n", options)).toBe(7);
+    });
+
+    test("clamps to the configured min and max", () => {
+      expect(ToolArgs.getNumber({ n: 1000 }, "n", options)).toBe(100);
+      expect(ToolArgs.getNumber({ n: -5 }, "n", options)).toBe(1);
+    });
+
+    test("falls back to the default for missing or invalid values", () => {
+      expect(ToolArgs.getNumber({}, "n", options)).toBe(10);
+      expect(ToolArgs.getNumber({ n: "abc" }, "n", options)).toBe(10);
+      expect(ToolArgs.getNumber({ n: NaN }, "n", options)).toBe(10);
+      expect(ToolArgs.getNumber({ n: Infinity }, "n", options)).toBe(10);
+      expect(ToolArgs.getNumber({ n: "" }, "n", options)).toBe(10);
+    });
+
+    test("still clamps the default value itself", () => {
+      // Default below min is raised to min; default above max lowered to max.
+      expect(
+        ToolArgs.getNumber({}, "n", { defaultValue: 0, min: 5, max: 100 }),
+      ).toBe(5);
+    });
+  });
+
+  describe("getBoolean", () => {
+    test("returns real booleans as-is", () => {
+      expect(ToolArgs.getBoolean({ b: true }, "b")).toBe(true);
+      expect(ToolArgs.getBoolean({ b: false }, "b")).toBe(false);
+    });
+
+    test("coerces the strings 'true' and 'false'", () => {
+      expect(ToolArgs.getBoolean({ b: "true" }, "b")).toBe(true);
+      expect(ToolArgs.getBoolean({ b: "false" }, "b")).toBe(false);
+    });
+
+    test("returns undefined for anything else", () => {
+      expect(ToolArgs.getBoolean({ b: "TRUE" }, "b")).toBeUndefined();
+      expect(ToolArgs.getBoolean({ b: 1 }, "b")).toBeUndefined();
+      expect(ToolArgs.getBoolean({ b: "yes" }, "b")).toBeUndefined();
+      expect(ToolArgs.getBoolean({}, "b")).toBeUndefined();
+    });
+  });
+
+  describe("getObjectID", () => {
+    test("wraps a non-empty string as an ObjectID", () => {
+      const id: ObjectID | undefined = ToolArgs.getObjectID(
+        { serviceId: "  abc123  " },
+        "serviceId",
+      );
+      expect(id).toBeInstanceOf(ObjectID);
+      // getString trims first, so the ObjectID carries the trimmed value.
+      expect(id?.toString()).toBe("abc123");
+    });
+
+    test("returns undefined for missing or empty values", () => {
+      expect(ToolArgs.getObjectID({}, "serviceId")).toBeUndefined();
+      expect(
+        ToolArgs.getObjectID({ serviceId: "   " }, "serviceId"),
+      ).toBeUndefined();
+      expect(
+        ToolArgs.getObjectID(
+          { serviceId: 5 as unknown as string } as JSONObject,
+          "serviceId",
+        ),
+      ).toBeUndefined();
+    });
+  });
+});

package/Tests/Server/Utils/AI/Toolbox/WidgetBuilder.test.ts

@@ -0,0 +1,205 @@
+import WidgetBuilder from "../../../../../Server/Utils/AI/Toolbox/WidgetBuilder";
+import { JSONObject } from "../../../../../Types/JSON";
+import {
+  AIChatCitationTarget,
+  AIChatWidget,
+  AIChatWidgetColumn,
+  AIChatWidgetSeries,
+  AIChatWidgetSpan,
+  AIChatWidgetStat,
+  AIChatWidgetType,
+} from "../../../../../Types/AI/AIChatTypes";
+
+/*
+ * WidgetBuilder is the factory the AI toolbox uses to attach inline widgets to
+ * a tool result. The shapes it produces are a contract with the frontend
+ * renderer, so this pins down the widget type, the data envelope, the defaults
+ * (bars.stacked / bars.xIsTime), and the invariant that id/citationId are left
+ * blank for ChatAgentRunner to mint.
+ */
+
+const link: AIChatCitationTarget = {
+  // A minimal citation target; only its presence is asserted below.
+} as AIChatCitationTarget;
+
+describe("WidgetBuilder", () => {
+  test("table() builds a Table widget carrying columns and rows", () => {
+    const columns: Array<AIChatWidgetColumn> = [
+      { key: "name", title: "Name" } as AIChatWidgetColumn,
+    ];
+    const rows: Array<JSONObject> = [{ name: "api" }, { name: "worker" }];
+
+    const widget: AIChatWidget = WidgetBuilder.table({
+      title: "Services",
+      description: "All services",
+      columns,
+      rows,
+      link,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.Table);
+    expect(widget.title).toBe("Services");
+    expect(widget.description).toBe("All services");
+    expect(widget.id).toBe("");
+    expect((widget.data as JSONObject)["columns"]).toBe(columns);
+    expect((widget.data as JSONObject)["rows"]).toBe(rows);
+    expect((widget.data as JSONObject)["link"]).toBe(link);
+  });
+
+  test("timeSeries() hardcodes xIsTime to true", () => {
+    const series: Array<AIChatWidgetSeries> = [
+      { name: "cpu", points: [] } as unknown as AIChatWidgetSeries,
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.timeSeries({
+      title: "CPU over time",
+      series,
+      unit: "%",
+      valueLabel: "CPU",
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.TimeSeriesChart);
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["xIsTime"]).toBe(true);
+    expect(data["unit"]).toBe("%");
+    expect(data["valueLabel"]).toBe("CPU");
+    expect(data["series"]).toBe(series);
+  });
+
+  test("bars() defaults stacked and xIsTime to false", () => {
+    const series: Array<AIChatWidgetSeries> = [
+      { name: "logs", points: [] } as unknown as AIChatWidgetSeries,
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.bars({
+      title: "Log volume",
+      series,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.BarChart);
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["stacked"]).toBe(false);
+    expect(data["xIsTime"]).toBe(false);
+  });
+
+  test("bars() honors explicit stacked and xIsTime flags", () => {
+    const widget: AIChatWidget = WidgetBuilder.bars({
+      title: "Log volume by severity",
+      series: [],
+      stacked: true,
+      xIsTime: true,
+    });
+
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["stacked"]).toBe(true);
+    expect(data["xIsTime"]).toBe(true);
+  });
+
+  test("bars() keeps a `false` flag rather than replacing it with the default", () => {
+    /*
+     * Regression guard for the `?? false` nullish coalescing: an explicit
+     * false must survive, and is indistinguishable from the default here —
+     * the point is that passing false does not throw or flip to true.
+     */
+    const widget: AIChatWidget = WidgetBuilder.bars({
+      title: "x",
+      series: [],
+      stacked: false,
+      xIsTime: false,
+    });
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["stacked"]).toBe(false);
+    expect(data["xIsTime"]).toBe(false);
+  });
+
+  test("traceWaterfall() carries spans and total duration", () => {
+    const spans: Array<AIChatWidgetSpan> = [
+      { name: "GET /", durationMs: 12 } as unknown as AIChatWidgetSpan,
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.traceWaterfall({
+      title: "Trace",
+      spans,
+      totalDurationMs: 120,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.TraceWaterfall);
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["spans"]).toBe(spans);
+    expect(data["totalDurationMs"]).toBe(120);
+  });
+
+  test("incidentList / alertList / exceptionList wrap items under the right type", () => {
+    const items: Array<JSONObject> = [{ id: "1" }];
+
+    const incident: AIChatWidget = WidgetBuilder.incidentList({
+      title: "Open incidents",
+      items,
+    });
+    expect(incident.type).toBe(AIChatWidgetType.IncidentList);
+    expect((incident.data as JSONObject)["items"]).toBe(items);
+
+    const alert: AIChatWidget = WidgetBuilder.alertList({
+      title: "Open alerts",
+      items,
+    });
+    expect(alert.type).toBe(AIChatWidgetType.AlertList);
+    expect((alert.data as JSONObject)["items"]).toBe(items);
+
+    const exception: AIChatWidget = WidgetBuilder.exceptionList({
+      title: "Exceptions",
+      items,
+    });
+    expect(exception.type).toBe(AIChatWidgetType.ExceptionList);
+    expect((exception.data as JSONObject)["items"]).toBe(items);
+  });
+
+  test("resourceCard() maps its heading/subheading/fields", () => {
+    const fields: Array<{ label: string; value: string }> = [
+      { label: "State", value: "Investigating" },
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.resourceCard({
+      title: "Incident",
+      resourceType: "Incident",
+      heading: "API is down",
+      subheading: "SEV1",
+      fields,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.ResourceCard);
+    const data: JSONObject = widget.data as JSONObject;
+    expect(data["resourceType"]).toBe("Incident");
+    expect(data["heading"]).toBe("API is down");
+    expect(data["subheading"]).toBe("SEV1");
+    expect(data["fields"]).toBe(fields);
+  });
+
+  test("stats() builds StatCards", () => {
+    const stats: Array<AIChatWidgetStat> = [
+      { label: "Errors", value: "42" } as unknown as AIChatWidgetStat,
+    ];
+
+    const widget: AIChatWidget = WidgetBuilder.stats({
+      title: "KPIs",
+      stats,
+    });
+
+    expect(widget.type).toBe(AIChatWidgetType.StatCards);
+    expect((widget.data as JSONObject)["stats"]).toBe(stats);
+  });
+
+  test("every builder leaves id blank for the runner to mint", () => {
+    const widgets: Array<AIChatWidget> = [
+      WidgetBuilder.table({ title: "t", columns: [], rows: [] }),
+      WidgetBuilder.timeSeries({ title: "t", series: [] }),
+      WidgetBuilder.bars({ title: "t", series: [] }),
+      WidgetBuilder.incidentList({ title: "t", items: [] }),
+      WidgetBuilder.stats({ title: "t", stats: [] }),
+    ];
+
+    for (const widget of widgets) {
+      expect(widget.id).toBe("");
+    }
+  });
+});

package/Tests/Server/Utils/Database/TruncateColumnValue.test.ts

@@ -0,0 +1,179 @@
+import {
+  truncateLongText,
+  truncateShortText,
+  truncateToLength,
+} from "../../../../Server/Utils/Database/TruncateColumnValue";
+import ColumnLength from "../../../../Types/Database/ColumnLength";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The clamp that keeps a single oversized value from aborting a 500-row
+ * bulk INSERT (issue #3006 follow-up). Everything here is about the
+ * boundary: clip one character too eagerly and legitimate values get
+ * silently corrupted; clip one too late and Postgres still raises 22001
+ * and drops the whole chunk.
+ */
+
+describe("truncateToLength", () => {
+  test("returns a short value untouched, by identity", () => {
+    const value: string = "nginx:1.27";
+    expect(truncateToLength(value, 100)).toBe(value);
+  });
+
+  test("returns a value of exactly maxLength untouched", () => {
+    /*
+     * The off-by-one that matters most: varchar(100) accepts exactly
+     * 100 characters, so clipping at 100 would corrupt a legal value.
+     */
+    const value: string = "a".repeat(100);
+    const result: string = truncateToLength(value, 100);
+    expect(result).toBe(value);
+    expect(result).toHaveLength(100);
+  });
+
+  test("clips a value one character too long down to exactly maxLength", () => {
+    const value: string = "a".repeat(101);
+    const result: string = truncateToLength(value, 100);
+    expect(result).toHaveLength(100);
+    expect(value.startsWith(result)).toBe(true);
+  });
+
+  test("clips a wildly oversized value down to exactly maxLength", () => {
+    const result: string = truncateToLength("b".repeat(5000), 100);
+    expect(result).toHaveLength(100);
+    expect(result).toBe("b".repeat(100));
+  });
+
+  test("the clipped value is always a prefix of the original", () => {
+    const value: string =
+      "ghcr.io/some-really-long-organization-name/some-really-long-repository-name:v1.2.3-rc.4-with-a-long-build-suffix";
+    const result: string = truncateToLength(value, 40);
+    expect(value.startsWith(result)).toBe(true);
+    expect(result).toHaveLength(40);
+  });
+
+  test("passes null through as null", () => {
+    expect(truncateToLength(null, 100)).toBeNull();
+  });
+
+  test("normalizes undefined to null, so it binds as SQL NULL", () => {
+    expect(truncateToLength(undefined, 100)).toBeNull();
+  });
+
+  test("keeps an empty string as a string, never as null", () => {
+    /*
+     * KubernetesContainer.podNamespaceKey is NOT NULL with a "" default
+     * for cluster-scoped pods — turning "" into NULL would break the
+     * insert and the unique index that covers it.
+     */
+    const result: string = truncateToLength("", 100);
+    expect(result).toBe("");
+    expect(result).not.toBeNull();
+  });
+
+  test("handles a maxLength of zero without throwing", () => {
+    expect(truncateToLength("anything", 0)).toBe("");
+  });
+
+  describe("multi-byte characters", () => {
+    /*
+     * Postgres counts varchar(n) in characters; JS counts string length
+     * in UTF-16 code units. Astral-plane characters (emoji, rare CJK)
+     * are two code units each, so clipping by code units is always
+     * conservative — but the cut must not land inside a surrogate pair.
+     */
+    test("never emits more characters than the column allows", () => {
+      const value: string = "😀".repeat(200); // 400 code units, 200 chars
+      const result: string = truncateToLength(value, 100);
+
+      expect(result.length).toBeLessThanOrEqual(100);
+      expect(Array.from(result).length).toBeLessThanOrEqual(100);
+    });
+
+    test("does not split a surrogate pair when the cut lands inside one", () => {
+      /*
+       * 99 ASCII + one 2-code-unit emoji = 101 code units; cut at 100
+       * would otherwise land between the emoji's two halves.
+       */
+      const value: string = `${"a".repeat(99)}😀`;
+      const result: string = truncateToLength(value, 100);
+
+      expect(result).toBe("a".repeat(99));
+      expect(result).not.toContain("\ud83d");
+      // A lone surrogate survives a round trip through UTF-8 as U+FFFD.
+      expect(Buffer.from(result, "utf8").toString("utf8")).toBe(result);
+    });
+
+    test("keeps a whole surrogate pair when it fits exactly", () => {
+      const value: string = `${"a".repeat(98)}😀b`; // 101 code units
+      const result: string = truncateToLength(value, 100);
+
+      expect(result).toBe(`${"a".repeat(98)}😀`);
+      expect(result).toHaveLength(100);
+      expect(Buffer.from(result, "utf8").toString("utf8")).toBe(result);
+    });
+
+    test("leaves a multi-byte value that fits completely alone", () => {
+      const value: string = "café-über-日本語";
+      expect(truncateToLength(value, 100)).toBe(value);
+    });
+  });
+});
+
+describe("truncateShortText", () => {
+  test("clamps at ColumnLength.ShortText", () => {
+    expect(truncateShortText("a".repeat(500))).toHaveLength(
+      ColumnLength.ShortText,
+    );
+  });
+
+  test("ColumnLength.ShortText is still 100, the varchar width it mirrors", () => {
+    expect(ColumnLength.ShortText).toBe(100);
+  });
+
+  test("agrees with truncateToLength at the same bound", () => {
+    const value: string = "z".repeat(250);
+    expect(truncateShortText(value)).toBe(
+      truncateToLength(value, ColumnLength.ShortText),
+    );
+  });
+
+  test("passes null and short values straight through", () => {
+    expect(truncateShortText(null)).toBeNull();
+    expect(truncateShortText("osd.3")).toBe("osd.3");
+  });
+});
+
+describe("truncateLongText", () => {
+  test("clamps at ColumnLength.LongText", () => {
+    expect(truncateLongText("a".repeat(5000))).toHaveLength(
+      ColumnLength.LongText,
+    );
+  });
+
+  test("ColumnLength.LongText is still 500, the varchar width it mirrors", () => {
+    expect(ColumnLength.LongText).toBe(500);
+  });
+
+  test("accepts a 253-character Kubernetes DNS-subdomain name untouched", () => {
+    /*
+     * The whole point of widening the name columns: the longest name
+     * Kubernetes itself will ever produce has to pass through unclipped.
+     */
+    const podName: string = "p".repeat(253);
+    expect(truncateLongText(podName)).toBe(podName);
+  });
+
+  test("is strictly more permissive than truncateShortText", () => {
+    const value: string = "c".repeat(400);
+    expect(truncateLongText(value)).toBe(value);
+    expect(truncateShortText(value)).toHaveLength(ColumnLength.ShortText);
+  });
+
+  test("passes null and short values straight through", () => {
+    expect(truncateLongText(null)).toBeNull();
+    expect(truncateLongText("ghcr.io/acme/api:1.2.3")).toBe(
+      "ghcr.io/acme/api:1.2.3",
+    );
+  });
+});