@oneuptime/common 12.0.33 → 13.0.0

package/Tests/Utils/API.test.ts

@@ -8,9 +8,11 @@ import Route from "../../Types/API/Route";
 import URL from "../../Types/API/URL";
 import Dictionary from "../../Types/Dictionary";
 import APIException from "../../Types/Exception/ApiException";
+import BadDataException from "../../Types/Exception/BadDataException";
 import GenericObject from "../../Types/GenericObject";
 import { JSONObject } from "../../Types/JSON";
 import API from "../../Utils/API";
+import { HTTPResponseBodyBudget } from "../../Utils/HTTPResponseBodyReader";
 import { expect, jest } from "@jest/globals";
 import axios, {
   AxiosError,
@@ -20,6 +22,7 @@ import axios, {
   AxiosStatic,
   Method,
 } from "axios";
+import { Readable } from "stream";
 
 const DEFAULT_HEADERS: Headers = {
   Accept: "application/json",
@@ -519,6 +522,311 @@ describe("API instance properties", () => {
 });
 
 describe("API.fetch with options", () => {
+  test("should forward response and request byte limits and disable implicit proxies", async () => {
+    mockedAxios.mockClear();
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({ data: responseData }),
+    );
+
+    await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(Protocol.HTTPS, "api.example.com", new Route("items")),
+      options: {
+        maxContentLength: 1024,
+        maxBodyLength: 2048,
+        disableProxy: true,
+      },
+    });
+
+    expect(mockedAxios.mock.calls[0]![0]).toMatchObject({
+      maxContentLength: 1024,
+      maxBodyLength: 2048,
+      proxy: false,
+    });
+  });
+
+  test("should preserve explicit zero-byte limits", async () => {
+    mockedAxios.mockClear();
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({ data: responseData }),
+    );
+
+    await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(Protocol.HTTPS, "api.example.com", new Route("items")),
+      options: {
+        maxContentLength: 0,
+        maxBodyLength: 0,
+      },
+    });
+
+    expect(mockedAxios.mock.calls[0]![0]).toMatchObject({
+      maxContentLength: 0,
+      maxBodyLength: 0,
+    });
+  });
+
+  test("should leave byte limits and proxy routing unset by default", async () => {
+    mockedAxios.mockClear();
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({ data: responseData }),
+    );
+
+    await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(Protocol.HTTPS, "api.example.com", new Route("items")),
+    });
+
+    const requestConfig: AxiosRequestConfig = mockedAxios.mock
+      .calls[0]![0] as AxiosRequestConfig;
+    expect(requestConfig).not.toHaveProperty("maxContentLength");
+    expect(requestConfig).not.toHaveProperty("maxBodyLength");
+    expect(requestConfig).not.toHaveProperty("proxy");
+  });
+
+  test("should use an internal validated dispatch URL without normalizing its path or query", async () => {
+    mockedAxios.mockClear();
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({ data: responseData }),
+    );
+    const dispatchUrl: string = "https://api.example.com/a//b?tag=one&tag=two";
+
+    await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(Protocol.HTTPS, "api.example.com", new Route("reported")),
+      options: { dispatchUrl: dispatchUrl },
+    });
+
+    expect((mockedAxios.mock.calls[0]![0] as AxiosRequestConfig).url).toBe(
+      dispatchUrl,
+    );
+  });
+
+  test("should forward AbortSignal and normalize a budgeted JSON stream", async () => {
+    mockedAxios.mockClear();
+    const controller: AbortController = new AbortController();
+    const json: string = JSON.stringify(responseData);
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(1024);
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({
+        data: Readable.from([Buffer.from(json)]),
+        status: 200,
+      }),
+    );
+
+    const response: HTTPResponse<JSONObject> = await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(
+        Protocol.HTTPS,
+        "api.example.com",
+        new Route("streamed-json"),
+      ),
+      options: {
+        signal: controller.signal,
+        responseBodyBudget: budget,
+        limitRedirectResponseBody: true,
+      },
+    });
+
+    expect(mockedAxios.mock.calls[0]![0]).toMatchObject({
+      signal: controller.signal,
+      responseType: "stream",
+      maxContentLength: -1,
+    });
+    expect(response.data).toEqual(responseData);
+    expect(budget.remainingBytes).toBe(1024 - Buffer.byteLength(json));
+  });
+
+  test("should strip a leading UTF-8 BOM before parsing a budgeted JSON stream", async () => {
+    mockedAxios.mockClear();
+    const bodyText: string = `\uFEFF${JSON.stringify(responseData)}`;
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(1024);
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({
+        data: Readable.from([Buffer.from(bodyText)]),
+        status: 200,
+      }),
+    );
+
+    const response: HTTPResponse<JSONObject> = await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(
+        Protocol.HTTPS,
+        "api.example.com",
+        new Route("streamed-json-bom"),
+      ),
+      options: { responseBodyBudget: budget },
+    });
+
+    expect(response.data).toEqual(responseData);
+    expect(budget.remainingBytes).toBe(1024 - Buffer.byteLength(bodyText));
+  });
+
+  test("should enforce a per-response cap without lowering the shared budget", async () => {
+    mockedAxios.mockClear();
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(100);
+    const body: Readable = Readable.from([Buffer.from("12345")]);
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({ data: body, status: 200 }),
+    );
+
+    await expect(
+      API.fetch({
+        method: HTTPMethod.GET,
+        url: new URL(
+          Protocol.HTTPS,
+          "api.example.com",
+          new Route("per-response-cap"),
+        ),
+        options: {
+          responseBodyBudget: budget,
+          maximumResponseBytes: 4,
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadDataException);
+
+    expect(body.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(95);
+  });
+
+  test("should allow HEAD Content-Length to describe a larger hypothetical GET body", async () => {
+    mockedAxios.mockClear();
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({
+        data: Readable.from([]),
+        status: 200,
+        headers: { "Content-Length": "1000000" },
+      }),
+    );
+
+    await expect(
+      API.fetch({
+        method: HTTPMethod.HEAD,
+        url: new URL(
+          Protocol.HTTPS,
+          "api.example.com",
+          new Route("head-content-length"),
+        ),
+        options: { responseBodyBudget: budget },
+      }),
+    ).resolves.toBeInstanceOf(HTTPResponse);
+    expect(budget.remainingBytes).toBe(4);
+  });
+
+  test("should normalize a streamed Axios error before constructing HTTPErrorResponse", async () => {
+    mockedAxios.mockClear();
+    HTTPErrorResponseMock.mockClear();
+    const errorBody: JSONObject = { message: "redirect response" };
+    const serializedBody: string = JSON.stringify(errorBody);
+    const responseHeaders: Headers = {
+      Location: "https://api.example.com/final",
+    };
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(100, 32);
+    mockedAxios.mockRejectedValueOnce(
+      createAxiosError({
+        response: createAxiosResponse({
+          status: 302,
+          data: Readable.from([Buffer.from(serializedBody)]),
+          headers: responseHeaders,
+        }),
+      }),
+    );
+
+    await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(Protocol.HTTPS, "api.example.com", new Route("redirect")),
+      options: {
+        responseBodyBudget: budget,
+        limitRedirectResponseBody: true,
+      },
+    });
+
+    expect(HTTPErrorResponseMock).toHaveBeenCalledWith(
+      302,
+      errorBody,
+      responseHeaders,
+    );
+    expect(budget.remainingBytes).toBe(100 - Buffer.byteLength(serializedBody));
+  });
+
+  test("should preserve streamed non-JSON response text", async () => {
+    mockedAxios.mockClear();
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(20);
+    mockedAxios.mockResolvedValueOnce(
+      createAxiosResponse({
+        data: Readable.from([Buffer.from("plain response")]),
+      }),
+    );
+
+    const response: HTTPResponse<JSONObject> = await API.fetch({
+      method: HTTPMethod.GET,
+      url: new URL(
+        Protocol.HTTPS,
+        "api.example.com",
+        new Route("streamed-text"),
+      ),
+      options: { responseBodyBudget: budget },
+    });
+
+    expect(response.data).toEqual({ data: "plain response" });
+    expect(budget.remainingBytes).toBe(6);
+  });
+
+  test("should never retry a successful response whose streamed body exceeds the budget", async () => {
+    mockedAxios.mockClear();
+    const oversizedBody: Readable = Readable.from([Buffer.from("12345")]);
+    mockedAxios.mockResolvedValue(
+      createAxiosResponse({ data: oversizedBody, status: 200 }),
+    );
+
+    await expect(
+      API.fetch({
+        method: HTTPMethod.GET,
+        url: new URL(Protocol.HTTPS, "api.example.com", new Route("oversized")),
+        options: {
+          retries: 5,
+          responseBodyBudget: new HTTPResponseBodyBudget(4),
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadDataException);
+
+    expect(mockedAxios).toHaveBeenCalledTimes(1);
+    expect(oversizedBody.destroyed).toBe(true);
+  });
+
+  test("should charge separate API calls against the same cumulative budget", async () => {
+    mockedAxios.mockClear();
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(6);
+    const secondBody: Readable = Readable.from([Buffer.from("defg")]);
+    mockedAxios
+      .mockResolvedValueOnce(
+        createAxiosResponse({ data: Readable.from([Buffer.from("abc")]) }),
+      )
+      .mockResolvedValueOnce(createAxiosResponse({ data: secondBody }));
+    const request: () => Promise<HTTPResponse<JSONObject>> = async (): Promise<
+      HTTPResponse<JSONObject>
+    > => {
+      return await API.fetch({
+        method: HTTPMethod.GET,
+        url: new URL(
+          Protocol.HTTPS,
+          "api.example.com",
+          new Route("cumulative"),
+        ),
+        options: { responseBodyBudget: budget },
+      });
+    };
+
+    await expect(request()).resolves.toMatchObject({
+      data: { data: "abc" },
+    });
+    expect(budget.remainingBytes).toBe(3);
+    await expect(request()).rejects.toBeInstanceOf(BadDataException);
+    expect(secondBody.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(0);
+  });
+
   test("should make request with query parameters", async () => {
     mockedAxios.mockResolvedValueOnce(
       createAxiosResponse({ data: responseData }),

package/Tests/Utils/Dashboard/Components/DashboardMonitorListComponent.test.ts

@@ -55,6 +55,7 @@ const EXPECTED_ARGUMENT_IDS: Array<ArgumentId> = [
   "monitorStatusIds",
   "monitorTypes",
   "labelIds",
+  "labelVariableId",
 ];
 
 const DISPLAY_SECTION_ARGUMENT_IDS: Array<ArgumentId> = [
@@ -68,6 +69,7 @@ const FILTER_SECTION_ARGUMENT_IDS: Array<ArgumentId> = [
   "monitorStatusIds",
   "monitorTypes",
   "labelIds",
+  "labelVariableId",
 ];
 
 const VALID_INPUT_TYPES: Set<string> = new Set<string>(
@@ -157,6 +159,7 @@ describe("DashboardMonitorListComponentUtil", () => {
       expect(component.arguments.monitorStatusIds).toBeUndefined();
       expect(component.arguments.monitorTypes).toBeUndefined();
       expect(component.arguments.labelIds).toBeUndefined();
+      expect(component.arguments.labelVariableId).toBeUndefined();
     });
 
     test("uses the same default row count that the maxRows field shows as its placeholder", () => {
@@ -188,7 +191,7 @@ describe("DashboardMonitorListComponentUtil", () => {
   });
 
   describe("getComponentConfigArguments", () => {
-    test("declares exactly the seven documented arguments, in form order", () => {
+    test("declares the documented arguments, in form order", () => {
       expect(
         getArguments().map((arg: MonitorListArgument) => {
           return arg.id;
@@ -343,6 +346,13 @@ describe("DashboardMonitorListComponentUtil", () => {
       expect(arg.dropdownOptions).toBeUndefined();
     });
 
+    test("declares a dedicated project-label variable binding alongside fixed labels", () => {
+      const arg: MonitorListArgument = getArgumentById("labelVariableId");
+      expect(arg.type).toBe(ComponentInputType.ProjectLabelVariable);
+      expect(arg.required).toBe(false);
+      expect(arg.entityFilterModelType).toBeUndefined();
+    });
+
     test("renders the monitor-type filter as a static multi-select, not an entity lookup", () => {
       const arg: MonitorListArgument = getArgumentById("monitorTypes");
 

package/Tests/Utils/Dashboard/LabelVariable.test.ts

@@ -0,0 +1,257 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import IncludesAnyOfGroups from "../../../Types/BaseDatabase/IncludesAnyOfGroups";
+import DashboardVariable, {
+  DashboardVariableType,
+} from "../../../Types/Dashboard/DashboardVariable";
+import JSONFunctions from "../../../Types/JSONFunctions";
+import DashboardLabelVariable from "../../../Utils/Dashboard/LabelVariable";
+
+const UNIT_660: string = "06600000-0000-4000-8000-000000000000";
+const UNIT_661: string = "06610000-0000-4000-8000-000000000000";
+const NETWORK: string = "00000000-0000-4000-8000-000000000001";
+
+function variable(
+  overrides: Partial<DashboardVariable> = {},
+): DashboardVariable {
+  return {
+    id: "unit",
+    name: "UNIT",
+    type: DashboardVariableType.ProjectLabel,
+    labelOptions: [
+      { label: "0660", value: UNIT_660 },
+      { label: "0661", value: UNIT_661 },
+    ],
+    ...overrides,
+  };
+}
+
+function filter(
+  overrides: Partial<DashboardVariable> = {},
+  labelIds?: Array<string>,
+): ReturnType<typeof DashboardLabelVariable.getFilter> {
+  return DashboardLabelVariable.getFilter({
+    labelVariableId: "unit",
+    labelIds,
+    variables: [variable(overrides)],
+  });
+}
+
+describe("project label dashboard variable filters", () => {
+  test("keeps existing widgets with fixed labels unchanged", () => {
+    expect(DashboardLabelVariable.getFilter({ labelIds: [NETWORK] })).toEqual(
+      new Includes([NETWORK]),
+    );
+    expect(DashboardLabelVariable.getFilter({})).toBeUndefined();
+  });
+
+  test("a title or an unbound variable does not change the query", () => {
+    expect(
+      DashboardLabelVariable.getFilter({
+        variables: [variable({ selectedValue: UNIT_660 })],
+      }),
+    ).toBeUndefined();
+  });
+
+  test.each([UNIT_660, UNIT_661])(
+    "filters by selected label ID %s",
+    (id: string) => {
+      expect(filter({ selectedValue: id })).toEqual(new Includes([id]));
+    },
+  );
+
+  test("uses an absent selection's default", () => {
+    expect(filter({ defaultValue: UNIT_660 })).toEqual(
+      new Includes([UNIT_660]),
+    );
+  });
+
+  test("All overrides a default and retains the fixed label condition", () => {
+    expect(
+      filter({ defaultValue: UNIT_660, selectedValue: "" }, [NETWORK]),
+    ).toEqual(new Includes([NETWORK]));
+    expect(filter({ selectedValue: "" })).toBeUndefined();
+  });
+
+  test("multi-select is OR within units and AND with fixed labels", () => {
+    expect(
+      filter({ isMultiSelect: true, selectedValues: [UNIT_660, UNIT_661] }, [
+        NETWORK,
+      ]),
+    ).toEqual(new IncludesAnyOfGroups([[NETWORK], [UNIT_660, UNIT_661]]));
+  });
+
+  test("empty multi-select ignores a stale scalar and default", () => {
+    expect(
+      filter(
+        {
+          isMultiSelect: true,
+          selectedValues: [],
+          selectedValue: UNIT_660,
+          defaultValue: UNIT_661,
+        },
+        [NETWORK],
+      ),
+    ).toEqual(new Includes([NETWORK]));
+  });
+
+  test("does not mutate saved configuration and deduplicates repeated picks", () => {
+    const saved: DashboardVariable = variable({
+      isMultiSelect: true,
+      selectedValues: [UNIT_660, UNIT_660],
+    });
+    const before: string = JSON.stringify(saved);
+    const fixed: Array<string> = [NETWORK, NETWORK];
+    expect(
+      DashboardLabelVariable.getFilter({
+        labelIds: fixed,
+        labelVariableId: saved.id,
+        variables: [saved],
+      }),
+    ).toEqual(new IncludesAnyOfGroups([[NETWORK], [UNIT_660]]));
+    expect(JSON.stringify(saved)).toBe(before);
+    expect(fixed).toEqual([NETWORK, NETWORK]);
+  });
+
+  test("binding survives a variable rename and display name changes", () => {
+    expect(
+      filter({
+        name: "BRANCH",
+        selectedValue: UNIT_660,
+        labelOptions: [{ label: "Renamed unit", value: UNIT_660 }],
+      }),
+    ).toEqual(new Includes([UNIT_660]));
+  });
+
+  test("missing, duplicate, or incompatible variable definitions are errors", () => {
+    for (const variables of [
+      [],
+      [variable(), variable()],
+      [variable({ type: DashboardVariableType.CustomList })],
+    ]) {
+      expect(() => {
+        return DashboardLabelVariable.getFilter({
+          labelVariableId: "unit",
+          variables,
+        });
+      }).toThrow(/label variable/);
+    }
+  });
+
+  test.each(["0660", NETWORK])(
+    "rejects selections not in the configured options: %s",
+    (selectedValue: string) => {
+      expect(() => {
+        return filter({ selectedValue });
+      }).toThrow(/offered by this dashboard/);
+    },
+  );
+
+  test("an invalid default does not silently fall back to all monitors", () => {
+    expect(() => {
+      return filter({ defaultValue: NETWORK });
+    }).toThrow(/offered by this dashboard/);
+  });
+
+  test("validates every multi-selection instead of dropping invalid values", () => {
+    expect(() => {
+      return filter({
+        isMultiSelect: true,
+        selectedValues: [UNIT_660, NETWORK],
+      });
+    }).toThrow(/offered by this dashboard/);
+  });
+
+  test("bounds multi-selection size", () => {
+    expect(() => {
+      return filter({
+        isMultiSelect: true,
+        selectedValues: Array(101).fill(UNIT_660) as Array<string>,
+      });
+    }).toThrow(/100 labels/);
+  });
+
+  test.each([
+    undefined,
+    [],
+    [{ label: "0660", value: "0660" }],
+    [{ label: "", value: UNIT_660 }],
+    [{ label: " ", value: UNIT_660 }],
+    [{ label: "x".repeat(1025), value: UNIT_660 }],
+    [
+      { label: "0660", value: UNIT_660 },
+      { label: "Duplicate", value: UNIT_660 },
+    ],
+    Array(1001).fill({ label: "0660", value: UNIT_660 }),
+  ])(
+    "rejects malformed label choices %#",
+    (labelOptions: DashboardVariable["labelOptions"]) => {
+      expect(() => {
+        return filter({ labelOptions });
+      }).toThrow();
+    },
+  );
+
+  test("filter operators survive the API serialization round trip", () => {
+    const original: IncludesAnyOfGroups = filter({ selectedValue: UNIT_660 }, [
+      NETWORK,
+    ]) as IncludesAnyOfGroups;
+    expect(
+      JSONFunctions.deserializeValue(JSONFunctions.serializeValue(original)),
+    ).toEqual(original);
+  });
+});
+
+describe("dashboard title display interpolation", () => {
+  test.each([
+    [{ selectedValue: UNIT_660 }, "0660 NETWORK"],
+    [{ defaultValue: UNIT_661 }, "0661 NETWORK"],
+    [{ selectedValue: "", defaultValue: UNIT_660 }, "All NETWORK"],
+    [
+      { isMultiSelect: true, selectedValues: [UNIT_660, UNIT_661] },
+      "0660, 0661 NETWORK",
+    ],
+    [
+      { isMultiSelect: true, selectedValues: [], defaultValue: UNIT_660 },
+      "All NETWORK",
+    ],
+    [{ selectedValue: NETWORK }, "Unavailable label NETWORK"],
+  ])(
+    "renders a label selection using display names %#",
+    (overrides: Partial<DashboardVariable>, expected: string) => {
+      expect(
+        DashboardLabelVariable.interpolateTitle("{{UNIT}} NETWORK", [
+          variable(overrides),
+        ]),
+      ).toBe(expected);
+    },
+  );
+
+  test("preserves unknown references and ordinary titles", () => {
+    expect(
+      DashboardLabelVariable.interpolateTitle("{{missing}} NETWORK", [
+        variable(),
+      ]),
+    ).toBe("{{missing}} NETWORK");
+    expect(DashboardLabelVariable.interpolateTitle("Monitors", [])).toBe(
+      "Monitors",
+    );
+    expect(
+      DashboardLabelVariable.interpolateTitle(undefined, []),
+    ).toBeUndefined();
+  });
+
+  test("supports multiple references and text values without interpreting markup", () => {
+    const text: DashboardVariable = {
+      id: "env",
+      name: "ENV",
+      type: DashboardVariableType.TextInput,
+      selectedValue: "<b>prod</b>",
+    };
+    expect(
+      DashboardLabelVariable.interpolateTitle("{{UNIT}} / {{ENV}} / {{UNIT}}", [
+        variable({ selectedValue: UNIT_660 }),
+        text,
+      ]),
+    ).toBe("0660 / <b>prod</b> / 0660");
+  });
+});