@oneuptime/common 11.5.13 → 11.6.1

package/Tests/Utils/Array.test.ts

@@ -0,0 +1,156 @@
+import ArrayUtil from "../../Utils/Array";
+import ObjectID from "../../Types/ObjectID";
+
+describe("ArrayUtil", () => {
+  describe("removeDuplicates", () => {
+    it("keeps the first occurrence of each value in order", () => {
+      expect(ArrayUtil.removeDuplicates([1, 2, 2, 3, 1])).toEqual([1, 2, 3]);
+    });
+
+    it("returns an empty array unchanged", () => {
+      expect(ArrayUtil.removeDuplicates([])).toEqual([]);
+    });
+
+    it("de-duplicates strings", () => {
+      expect(ArrayUtil.removeDuplicates(["a", "b", "a"])).toEqual(["a", "b"]);
+    });
+  });
+
+  describe("mergeStringArrays", () => {
+    it("concatenates and removes duplicates", () => {
+      expect(ArrayUtil.mergeStringArrays(["a", "b"], ["b", "c"])).toEqual([
+        "a",
+        "b",
+        "c",
+      ]);
+    });
+
+    it("handles empty inputs on either side", () => {
+      expect(ArrayUtil.mergeStringArrays([], ["x"])).toEqual(["x"]);
+      expect(ArrayUtil.mergeStringArrays(["x"], [])).toEqual(["x"]);
+    });
+  });
+
+  describe("isEqual / isStringArrayEqual", () => {
+    it("is true for arrays with the same members regardless of order", () => {
+      expect(ArrayUtil.isEqual([1, 2, 3], [3, 2, 1])).toBe(true);
+      expect(ArrayUtil.isStringArrayEqual(["a", "b"], ["b", "a"])).toBe(true);
+    });
+
+    it("is false for different lengths", () => {
+      expect(ArrayUtil.isEqual([1, 2], [1, 2, 3])).toBe(false);
+    });
+
+    it("is false for different members", () => {
+      expect(ArrayUtil.isEqual([1, 2, 3], [1, 2, 4])).toBe(false);
+    });
+
+    it("is true for two empty arrays", () => {
+      expect(ArrayUtil.isEqual([], [])).toBe(true);
+    });
+  });
+
+  describe("shuffle", () => {
+    it("returns a new array with the same members", () => {
+      const input: Array<number> = [1, 2, 3, 4, 5];
+      const shuffled: Array<number> = ArrayUtil.shuffle(input);
+      expect(shuffled).not.toBe(input);
+      expect([...shuffled].sort()).toEqual([...input].sort());
+    });
+
+    it("does not mutate the input array", () => {
+      const input: Array<number> = [1, 2, 3];
+      const copy: Array<number> = [...input];
+      ArrayUtil.shuffle(input);
+      expect(input).toEqual(copy);
+    });
+
+    it("handles empty and single-element arrays", () => {
+      expect(ArrayUtil.shuffle([])).toEqual([]);
+      expect(ArrayUtil.shuffle([9])).toEqual([9]);
+    });
+  });
+
+  describe("removeDuplicatesFromObjectIDArray", () => {
+    it("de-duplicates by string value", () => {
+      const id1: ObjectID = new ObjectID(
+        "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+      );
+      const id1Dup: ObjectID = new ObjectID(
+        "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+      );
+      const id2: ObjectID = new ObjectID(
+        "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+      );
+
+      const result: Array<ObjectID> =
+        ArrayUtil.removeDuplicatesFromObjectIDArray([id1, id1Dup, id2]);
+
+      expect(result).toHaveLength(2);
+      expect(
+        result.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      ).toEqual([id1.toString(), id2.toString()]);
+    });
+
+    it("returns an empty array unchanged", () => {
+      expect(ArrayUtil.removeDuplicatesFromObjectIDArray([])).toEqual([]);
+    });
+  });
+
+  describe("sortByFieldName", () => {
+    it("sorts objects ascending by the given field", () => {
+      const rows: Array<{ name: string; age: number }> = [
+        { name: "c", age: 3 },
+        { name: "a", age: 1 },
+        { name: "b", age: 2 },
+      ];
+      rows.sort(ArrayUtil.sortByFieldName("age"));
+      expect(
+        rows.map((r: { name: string }) => {
+          return r.name;
+        }),
+      ).toEqual(["a", "b", "c"]);
+    });
+
+    it("returns 0 for equal field values", () => {
+      const comparator: (a: any, b: any) => number =
+        ArrayUtil.sortByFieldName("age");
+      expect(comparator({ age: 5 }, { age: 5 })).toBe(0);
+    });
+  });
+
+  describe("selectItemByRandom", () => {
+    it("returns a member of the array", () => {
+      const arr: Array<string> = ["x", "y", "z"];
+      for (let i: number = 0; i < 100; i++) {
+        expect(arr).toContain(ArrayUtil.selectItemByRandom(arr));
+      }
+    });
+
+    it("returns the only element of a single-element array", () => {
+      expect(ArrayUtil.selectItemByRandom(["only"])).toBe("only");
+    });
+  });
+
+  describe("distinctByFieldName", () => {
+    it("keeps the first object for each distinct field value", () => {
+      const rows: Array<{ group: string; id: number }> = [
+        { group: "a", id: 1 },
+        { group: "b", id: 2 },
+        { group: "a", id: 3 },
+      ];
+      const result: Array<{ group: string; id: number }> =
+        ArrayUtil.distinctByFieldName(rows, "group");
+      expect(result).toEqual([
+        { group: "a", id: 1 },
+        { group: "b", id: 2 },
+      ]);
+    });
+
+    it("returns an empty array unchanged", () => {
+      expect(ArrayUtil.distinctByFieldName([], "group")).toEqual([]);
+    });
+  });
+});

package/Tests/Utils/CronTab.test.ts

@@ -0,0 +1,199 @@
+import CronTab, { CronPreset } from "../../Utils/CronTab";
+import cronParser from "cron-parser";
+
+/**
+ * These tests cross-check our dependency-free CronTab engine against
+ * `cron-parser` (the library BullMQ actually uses to fire repeatable jobs), so
+ * the picker's preview and validation stay faithful to real firing behavior.
+ */
+
+const FIXED_FROM: Date = new Date(Date.UTC(2026, 0, 1, 0, 0, 30));
+
+function cronParserNextTimes(
+  expression: string,
+  count: number,
+  from: Date,
+): Array<number> {
+  const interval: {
+    next: () => { toDate: () => Date };
+  } = cronParser.parseExpression(expression, {
+    currentDate: from,
+    tz: "UTC",
+  }) as unknown as { next: () => { toDate: () => Date } };
+
+  const times: Array<number> = [];
+  for (let i: number = 0; i < count; i++) {
+    times.push(interval.next().toDate().getTime());
+  }
+  return times;
+}
+
+describe("CronTab", () => {
+  describe("isVariableExpression", () => {
+    test("detects workflow variable references", () => {
+      expect(CronTab.isVariableExpression("{{local.variables.schedule}}")).toBe(
+        true,
+      );
+      expect(
+        CronTab.isVariableExpression("* */{{local.variables.h}} * * *"),
+      ).toBe(true);
+    });
+
+    test("returns false for plain cron expressions", () => {
+      expect(CronTab.isVariableExpression("0 */18 * * *")).toBe(false);
+      expect(CronTab.isVariableExpression("* * * * *")).toBe(false);
+    });
+  });
+
+  describe("validation", () => {
+    const validExpressions: Array<string> = [
+      "* * * * *",
+      "*/5 * * * *",
+      "0 */18 * * *",
+      "0 0 * * *",
+      "30 9 * * 1-5",
+      "0 0 1 */3 *",
+      "0 0 1 1 *",
+      "15,45 * * * *",
+      "0 0 * * MON",
+      "0 0 1 JAN *",
+      "0 0 * * 7",
+      "*/15 9-17 * * MON-FRI",
+      "30 2 * * * ", // trailing space
+      "0 0 * * SUN,SAT",
+      "5/10 * * * *",
+    ];
+
+    test.each(validExpressions)(
+      "accepts valid expression %s",
+      (expr: string) => {
+        expect(CronTab.getValidationError(expr)).toBeNull();
+        expect(CronTab.isValid(expr)).toBe(true);
+      },
+    );
+
+    const invalidExpressions: Array<string> = [
+      "",
+      "* * * *", // 4 fields
+      "* * * * * * *", // 7 fields
+      "60 * * * *", // minute out of range
+      "* 24 * * *", // hour out of range
+      "* * 32 * *", // dom out of range
+      "* * * 13 *", // month out of range
+      "* * * * 8", // dow out of range
+      "*/0 * * * *", // step 0
+      "abc * * * *", // not a number
+      "5-1 * * * *", // reversed range
+      "* * * * FUN", // bad day name
+    ];
+
+    test.each(invalidExpressions)(
+      "rejects invalid expression %s",
+      (expr: string) => {
+        expect(CronTab.getValidationError(expr)).not.toBeNull();
+        expect(CronTab.isValid(expr)).toBe(false);
+      },
+    );
+
+    test("variable expressions are not flagged as validation errors", () => {
+      expect(
+        CronTab.getValidationError("{{local.variables.schedule}}"),
+      ).toBeNull();
+      // ...but they are not "valid" concrete crons either.
+      expect(CronTab.isValid("{{local.variables.schedule}}")).toBe(false);
+    });
+  });
+
+  describe("all presets are valid and describable", () => {
+    test.each(
+      CronTab.PRESETS.map((p: CronPreset) => {
+        return p.value;
+      }),
+    )("preset %s", (value: string) => {
+      expect(CronTab.isValid(value)).toBe(true);
+      expect(CronTab.getHumanReadableDescription(value)).toBeTruthy();
+      // cron-parser must also accept it (guards against BullMQ rejecting).
+      expect(() => {
+        return cronParser.parseExpression(value, { tz: "UTC" });
+      }).not.toThrow();
+    });
+  });
+
+  describe("next execution times match cron-parser", () => {
+    const expressions: Array<string> = [
+      "* * * * *",
+      "*/5 * * * *",
+      "*/30 * * * *",
+      "0 * * * *",
+      "0 */3 * * *",
+      "0 */18 * * *",
+      "0 0 * * *",
+      "30 9 * * *",
+      "0 0 * * 0",
+      "0 0 * * 1-5",
+      "0 0 1 * *",
+      "0 0 1 */3 *",
+      "0 0 29 2 *", // leap-day only — sparse, exercises month/day jumps
+      "15,45 8-10 * * *",
+      "0 12 1,15 * *",
+    ];
+
+    test.each(expressions)("next 8 runs for %s", (expr: string) => {
+      const ours: Array<number> = CronTab.getNextExecutionTimes(
+        expr,
+        8,
+        FIXED_FROM,
+      ).map((d: Date) => {
+        return d.getTime();
+      });
+
+      const theirs: Array<number> = cronParserNextTimes(expr, 8, FIXED_FROM);
+
+      expect(ours).toEqual(theirs);
+    });
+  });
+
+  describe("human-readable descriptions", () => {
+    const cases: Array<[string, string]> = [
+      ["* * * * *", "Every minute"],
+      ["*/5 * * * *", "Every 5 minutes"],
+      ["*/30 * * * *", "Every 30 minutes"],
+      ["0 * * * *", "Every hour, on the hour"],
+      ["0 */2 * * *", "Every 2 hours"],
+      ["0 */18 * * *", "Every 18 hours"],
+      ["0 0 * * *", "Every day at 00:00 (UTC)"],
+      ["30 9 * * *", "Every day at 09:30 (UTC)"],
+      ["0 9 * * 1", "Every week on Monday at 09:00 (UTC)"],
+      ["0 0 * * 0", "Every week on Sunday at 00:00 (UTC)"],
+      ["0 0 1 * *", "Every month on the 1st at 00:00 (UTC)"],
+      ["0 0 1 */3 *", "Every 3 months on the 1st at 00:00 (UTC)"],
+      ["0 0 1 1 *", "On the 1st of January at 00:00 (UTC)"],
+    ];
+
+    test.each(cases)("describes %s as %s", (expr: string, expected: string) => {
+      expect(CronTab.getHumanReadableDescription(expr)).toBe(expected);
+    });
+
+    test("returns null for invalid expressions", () => {
+      expect(CronTab.getHumanReadableDescription("nonsense")).toBeNull();
+    });
+  });
+
+  describe("next execution times are in the future and ascending", () => {
+    test("returns the requested count in strictly increasing order", () => {
+      const times: Array<Date> = CronTab.getNextExecutionTimes(
+        "*/15 * * * *",
+        5,
+        FIXED_FROM,
+      );
+
+      expect(times).toHaveLength(5);
+      for (let i: number = 0; i < times.length; i++) {
+        expect(times[i]!.getTime()).toBeGreaterThan(FIXED_FROM.getTime());
+        if (i > 0) {
+          expect(times[i]!.getTime()).toBeGreaterThan(times[i - 1]!.getTime());
+        }
+      }
+    });
+  });
+});

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

@@ -0,0 +1,197 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import DashboardVariable, {
+  DashboardVariableType,
+} from "../../../Types/Dashboard/DashboardVariable";
+import DashboardVariableInterpolation from "../../../Utils/Dashboard/VariableInterpolation";
+
+function makeVariable(
+  overrides: Partial<DashboardVariable>,
+): DashboardVariable {
+  return {
+    id: "var-1",
+    name: "cluster",
+    type: DashboardVariableType.TelemetryAttribute,
+    ...overrides,
+  } as DashboardVariable;
+}
+
+describe("DashboardVariableInterpolation", () => {
+  describe("resolveValue", () => {
+    test("returns scalar for a single-select with selectedValue", () => {
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "prod",
+      });
+    });
+
+    test("falls back to defaultValue when selectedValue is unset", () => {
+      const variable: DashboardVariable = makeVariable({
+        defaultValue: "staging",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "staging",
+      });
+    });
+
+    test("prefers selectedValue over defaultValue", () => {
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+        defaultValue: "staging",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "prod",
+      });
+    });
+
+    test("returns undefined when nothing is selected", () => {
+      expect(
+        DashboardVariableInterpolation.resolveValue(makeVariable({})),
+      ).toBeUndefined();
+      expect(
+        DashboardVariableInterpolation.resolveValue(
+          makeVariable({ selectedValue: "" }),
+        ),
+      ).toBeUndefined();
+    });
+
+    test("returns multi for a multi-select with values", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: ["a", "b"],
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        multi: ["a", "b"],
+      });
+    });
+
+    test("filters out empty values in multi-select", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: ["a", "", "b"],
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        multi: ["a", "b"],
+      });
+    });
+
+    test("multi-select with no picks falls through to scalar default", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: [],
+        defaultValue: "d",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "d",
+      });
+    });
+  });
+
+  describe("applyToAttributes", () => {
+    test("returns the same reference when there are no variables", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, undefined),
+      ).toBe(attrs);
+      expect(DashboardVariableInterpolation.applyToAttributes(attrs, [])).toBe(
+        attrs,
+      );
+    });
+
+    test("injects a scalar attribute for a selected variable", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [variable]);
+      expect(result).toEqual({ "k8s.cluster.name": "prod" });
+    });
+
+    test("emits an Includes operator for multi-select", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        isMultiSelect: true,
+        selectedValues: ["a", "b"],
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [variable]);
+      const value: unknown = result["k8s.cluster.name"];
+      expect(value).toBeInstanceOf(Includes);
+      expect((value as Includes).values).toEqual(["a", "b"]);
+    });
+
+    test("removes a previously-set filter when selection is cleared (All)", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(
+          { "k8s.cluster.name": "prod", other: "keep" },
+          [variable],
+        );
+      expect(result).toEqual({ other: "keep" });
+    });
+
+    test("ignores non-TelemetryAttribute variables", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      const variable: DashboardVariable = makeVariable({
+        type: DashboardVariableType.TextInput,
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("ignores TelemetryAttribute variables without an attributeKey", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("returns same reference when scalar value is already set", () => {
+      const attrs: Record<string, unknown> = { "k8s.cluster.name": "prod" };
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("handles undefined attributes map", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(undefined, [variable]);
+      expect(result).toEqual({ "k8s.cluster.name": "prod" });
+    });
+
+    test("applies multiple variables at once", () => {
+      const v1: DashboardVariable = makeVariable({
+        id: "v1",
+        attributeKey: "cluster",
+        selectedValue: "prod",
+      });
+      const v2: DashboardVariable = makeVariable({
+        id: "v2",
+        attributeKey: "namespace",
+        selectedValue: "default",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [v1, v2]);
+      expect(result).toEqual({ cluster: "prod", namespace: "default" });
+    });
+  });
+});

package/Tests/Utils/ModelImportExport.test.ts

@@ -2,6 +2,7 @@ import Dashboard from "../../Models/DatabaseModels/Dashboard";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import ScheduledMaintenanceTemplate from "../../Models/DatabaseModels/ScheduledMaintenanceTemplate";
 import StatusPage from "../../Models/DatabaseModels/StatusPage";
+import Workflow from "../../Models/DatabaseModels/Workflow";
 import EventInterval from "../../Types/Events/EventInterval";
 import Recurring from "../../Types/Events/Recurring";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -86,6 +87,35 @@ describe("ModelImportExport", () => {
       expect(columns).not.toContain("embeddedOverallStatusToken");
     });
 
+    test("should include the workflow graph and its own settings", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Workflow);
+
+      expect(columns).toContain("name");
+      expect(columns).toContain("description");
+      expect(columns).toContain("graph");
+      expect(columns).toContain("isEnabled");
+    });
+
+    test("should exclude workflow secrets and server-derived trigger state", () => {
+      const columns: Array<string> =
+        ModelImportExport.getImportExportableColumnNames(Workflow);
+
+      /*
+       * These all carry create: [] access control - they are derived from the
+       * graph or generated on create, and re-importing them would either leak
+       * the source workflow's webhook secret or point the runner at stale
+       * trigger state.
+       */
+      expect(columns).not.toContain("webhookSecretKey");
+      expect(columns).not.toContain("triggerId");
+      expect(columns).not.toContain("triggerArguments");
+      expect(columns).not.toContain("repeatableJobKey");
+      expect(columns).not.toContain("slug");
+      expect(columns).not.toContain("projectId");
+      expect(columns).not.toContain("labels");
+    });
+
     test("should exclude monitor runtime-state columns", () => {
       const columns: Array<string> =
         ModelImportExport.getImportExportableColumnNames(Monitor);
@@ -267,6 +297,77 @@ describe("ModelImportExport", () => {
       expect(imported._id).toBeUndefined();
     });
 
+    test("should round-trip a workflow graph and drop its webhook secret", () => {
+      const graph: JSONObject = {
+        nodes: [
+          {
+            id: "node-1",
+            data: {
+              metadataId: "Webhook",
+              componentType: "Trigger",
+              nodeType: "Node",
+              arguments: {},
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const original: Workflow = new Workflow();
+      original.name = "Deploy Notifier";
+      original.description = "Posts to chat on deploy";
+      original.isEnabled = true;
+      original.graph = graph;
+      original.webhookSecretKey = "super-secret-key";
+      original.triggerId = "Webhook";
+      original.slug = "deploy-notifier";
+
+      const envelope: JSONObject = ModelImportExport.buildExportEnvelope({
+        modelType: Workflow,
+        items: [original],
+        exportedAt: new Date(),
+      });
+
+      const exported: JSONObject = (envelope["items"] as Array<JSONObject>)[0]!;
+
+      expect(exported["graph"]).toEqual(graph);
+      expect(exported["isEnabled"]).toBe(true);
+      expect(exported["webhookSecretKey"]).toBeUndefined();
+      expect(exported["triggerId"]).toBeUndefined();
+      expect(exported["slug"]).toBeUndefined();
+
+      const imported: Workflow = ModelImportExport.fromImportJSON({
+        json: exported,
+        modelType: Workflow,
+      });
+
+      expect(imported.name).toBe("Deploy Notifier");
+      expect(imported.description).toBe("Posts to chat on deploy");
+      expect(imported.graph).toEqual(graph);
+      expect(imported.webhookSecretKey).toBeUndefined();
+      expect(imported.triggerId).toBeUndefined();
+      expect(imported._id).toBeUndefined();
+    });
+
+    test("should import workflows disabled even when exported enabled", () => {
+      /*
+       * An imported workflow can reference resources that do not exist here,
+       * and enabling it starts it firing - so it must land disabled and be
+       * turned on deliberately.
+       */
+      const imported: Workflow = ModelImportExport.fromImportJSON({
+        json: {
+          name: "Pager Escalation",
+          isEnabled: true,
+          graph: { nodes: [], edges: [] },
+        },
+        modelType: Workflow,
+      });
+
+      expect(imported.name).toBe("Pager Escalation");
+      expect(imported.isEnabled).toBe(false);
+    });
+
     test("should advance past recurring dates for scheduled maintenance templates", () => {
       const dayInMs: number = 24 * 60 * 60 * 1000;