@oneuptime/common 12.0.33 → 13.0.0

package/Tests/Server/Utils/CustomField/CustomFieldMappingValidator.test.ts

@@ -0,0 +1,437 @@
+import { afterEach, describe, expect, test } from "@jest/globals";
+import CustomFieldMappingSourceResource from "../../../../Types/CustomField/CustomFieldMappingSourceResource";
+import CustomFieldType from "../../../../Types/CustomField/CustomFieldType";
+import { JSONObject } from "../../../../Types/JSON";
+import ObjectID from "../../../../Types/ObjectID";
+import AlertCustomField from "../../../../Models/DatabaseModels/AlertCustomField";
+import MonitorCustomField from "../../../../Models/DatabaseModels/MonitorCustomField";
+import TeamCustomField from "../../../../Models/DatabaseModels/TeamCustomField";
+import AlertCustomFieldService from "../../../../Server/Services/AlertCustomFieldService";
+import MonitorCustomFieldService from "../../../../Server/Services/MonitorCustomFieldService";
+import CreateBy from "../../../../Server/Types/Database/CreateBy";
+import UpdateBy from "../../../../Server/Types/Database/UpdateBy";
+import {
+  normalizeCustomFieldMappingPayload,
+  validateCustomFieldMappingOnCreate,
+  validateCustomFieldMappingOnUpdate,
+} from "../../../../Server/Utils/CustomField/CustomFieldMappingValidator";
+
+/*
+ * Saving a custom field definition is the only moment a person is present to
+ * be told a mapping cannot work, and the only moment anything on the server
+ * looks at a custom field's shape at all — values are never validated against
+ * their definition anywhere else. So a mapping accepted here that turns out to
+ * be impossible does not fail loudly later; it quietly copies nothing, or
+ * copies a dropdown value the target cannot offer and therefore cannot be
+ * filtered by.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+
+type StubMonitorFieldFunction = (
+  definitions: Array<Partial<MonitorCustomField>>,
+) => void;
+
+const stubMonitorFields: StubMonitorFieldFunction = (
+  definitions: Array<Partial<MonitorCustomField>>,
+): void => {
+  jest.spyOn(MonitorCustomFieldService, "findBy").mockResolvedValue(
+    definitions.map((definition: Partial<MonitorCustomField>) => {
+      return Object.assign(new MonitorCustomField(), definition);
+    }) as never,
+  );
+};
+
+type BuildCreateByFunction = (data: JSONObject) => CreateBy<AlertCustomField>;
+
+const buildCreateBy: BuildCreateByFunction = (
+  data: JSONObject,
+): CreateBy<AlertCustomField> => {
+  return {
+    data: Object.assign(new AlertCustomField(), data),
+    props: { isRoot: true, tenantId: PROJECT_ID },
+  } as CreateBy<AlertCustomField>;
+};
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("normalizeCustomFieldMappingPayload", () => {
+  /*
+   * `showIf` hides a form field but does not strip it from the submitted
+   * values — BasicForm posts the whole bag — so clearing "Map value from"
+   * leaves the field name behind and would persist half a mapping.
+   */
+  test("clears the field name when the resource is cleared", () => {
+    const payload: JSONObject = {
+      mapFromResourceType: "",
+      mapFromCustomFieldName: "Vendor",
+    };
+
+    normalizeCustomFieldMappingPayload(payload as Record<string, unknown>);
+
+    expect(payload["mapFromResourceType"]).toBeNull();
+    expect(payload["mapFromCustomFieldName"]).toBeNull();
+  });
+
+  test("clears the resource when the field name is cleared", () => {
+    const payload: JSONObject = {
+      mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+      mapFromCustomFieldName: "",
+    };
+
+    normalizeCustomFieldMappingPayload(payload as Record<string, unknown>);
+
+    expect(payload["mapFromResourceType"]).toBeNull();
+    expect(payload["mapFromCustomFieldName"]).toBeNull();
+  });
+
+  test("trims a complete mapping and leaves it in place", () => {
+    const payload: JSONObject = {
+      mapFromResourceType: " Monitor ",
+      mapFromCustomFieldName: " Vendor ",
+    };
+
+    normalizeCustomFieldMappingPayload(payload as Record<string, unknown>);
+
+    expect(payload["mapFromResourceType"]).toBe("Monitor");
+    expect(payload["mapFromCustomFieldName"]).toBe("Vendor");
+  });
+
+  /*
+   * An update that renames the field must not be read as an instruction to
+   * drop a mapping it never mentioned.
+   */
+  test("leaves a payload that mentions neither key untouched", () => {
+    const payload: JSONObject = { name: "Vendor" };
+
+    normalizeCustomFieldMappingPayload(payload as Record<string, unknown>);
+
+    expect(payload).toEqual({ name: "Vendor" });
+  });
+
+  /*
+   * The regression that made this rule explicit. An update payload is a
+   * PARTIAL: repointing a mapping at another field mentions only the field
+   * name, and reading the absent resource as "cleared" deleted the working
+   * mapping instead of validating the new one.
+   */
+  test("does not read an absent key as a cleared one", () => {
+    const payload: JSONObject = { mapFromCustomFieldName: "Supplier" };
+
+    normalizeCustomFieldMappingPayload(payload as Record<string, unknown>);
+
+    expect(payload).toEqual({ mapFromCustomFieldName: "Supplier" });
+  });
+});
+
+describe("validateCustomFieldMappingOnCreate", () => {
+  test("accepts a mapping onto a source field of the same type", async () => {
+    stubMonitorFields([
+      { name: "Vendor", customFieldType: CustomFieldType.Text },
+    ]);
+
+    await expect(
+      validateCustomFieldMappingOnCreate({
+        definitionModelType: AlertCustomField,
+        createBy: buildCreateBy({
+          name: "Vendor",
+          customFieldType: CustomFieldType.Text,
+          mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+          mapFromCustomFieldName: "Vendor",
+        }),
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  test("accepts a definition with no mapping without reading the source table", async () => {
+    const findMonitorFields: jest.SpyInstance = jest
+      .spyOn(MonitorCustomFieldService, "findBy")
+      .mockResolvedValue([] as never);
+
+    await validateCustomFieldMappingOnCreate({
+      definitionModelType: AlertCustomField,
+      createBy: buildCreateBy({
+        name: "Vendor",
+        customFieldType: CustomFieldType.Text,
+      }),
+    });
+
+    expect(findMonitorFields).not.toHaveBeenCalled();
+  });
+
+  test("rejects a source field that does not exist", async () => {
+    stubMonitorFields([]);
+
+    await expect(
+      validateCustomFieldMappingOnCreate({
+        definitionModelType: AlertCustomField,
+        createBy: buildCreateBy({
+          name: "Vendor",
+          customFieldType: CustomFieldType.Text,
+          mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+          mapFromCustomFieldName: "Vendor",
+        }),
+      }),
+    ).rejects.toThrow(/does not have a custom field called "Vendor"/);
+  });
+
+  test("rejects a source field of a different type", async () => {
+    stubMonitorFields([
+      { name: "Vendor", customFieldType: CustomFieldType.Number },
+    ]);
+
+    await expect(
+      validateCustomFieldMappingOnCreate({
+        definitionModelType: AlertCustomField,
+        createBy: buildCreateBy({
+          name: "Vendor",
+          customFieldType: CustomFieldType.Text,
+          mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+          mapFromCustomFieldName: "Vendor",
+        }),
+      }),
+    ).rejects.toThrow(/same type/);
+  });
+
+  /*
+   * The facet chip's options come from the TARGET definition, so a copied
+   * value outside that list is stored, drawn as an uncoloured badge, and
+   * cannot be filtered for.
+   */
+  test("rejects a dropdown source that can hold options this field does not offer", async () => {
+    stubMonitorFields([
+      {
+        name: "Vendor",
+        customFieldType: CustomFieldType.Dropdown,
+        dropdownOptions: "Acme\nAWS",
+      },
+    ]);
+
+    await expect(
+      validateCustomFieldMappingOnCreate({
+        definitionModelType: AlertCustomField,
+        createBy: buildCreateBy({
+          name: "Vendor",
+          customFieldType: CustomFieldType.Dropdown,
+          dropdownOptions: "Acme\nGlobex",
+          mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+          mapFromCustomFieldName: "Vendor",
+        }),
+      }),
+    ).rejects.toThrow(/AWS/);
+  });
+
+  /*
+   * The mapping columns exist on all nine definition tables for lockstep with
+   * their siblings, but six of those resources have nothing to inherit from.
+   * Accepting a value there would store a mapping that can never resolve.
+   */
+  test("rejects a mapping on a resource with no reachable source", async () => {
+    await expect(
+      validateCustomFieldMappingOnCreate({
+        definitionModelType: TeamCustomField,
+        createBy: {
+          data: Object.assign(new TeamCustomField(), {
+            name: "Vendor",
+            customFieldType: CustomFieldType.Text,
+            mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+            mapFromCustomFieldName: "Vendor",
+          }),
+          props: { isRoot: true, tenantId: PROJECT_ID },
+        } as CreateBy<TeamCustomField>,
+      }),
+    ).rejects.toThrow(/cannot take their value from another resource/);
+  });
+
+  test("allows an unmapped definition on a resource with no reachable source", async () => {
+    await expect(
+      validateCustomFieldMappingOnCreate({
+        definitionModelType: TeamCustomField,
+        createBy: {
+          data: Object.assign(new TeamCustomField(), {
+            name: "Vendor",
+            customFieldType: CustomFieldType.Text,
+          }),
+          props: { isRoot: true, tenantId: PROJECT_ID },
+        } as CreateBy<TeamCustomField>,
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  /*
+   * `customFieldType` is nullable, so two untyped definitions would otherwise
+   * pass an `undefined === undefined` comparison and let any value shape flow.
+   */
+  /*
+   * Half a mapping resolves nothing and would show in the settings table as a
+   * field claiming to be mapped to nowhere.
+   */
+  test("rejects a resource with no field chosen", async () => {
+    await expect(
+      validateCustomFieldMappingOnCreate({
+        definitionModelType: AlertCustomField,
+        createBy: buildCreateBy({
+          name: "Vendor",
+          customFieldType: CustomFieldType.Text,
+          mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+        }),
+      }),
+    ).rejects.toThrow(/Choose both/);
+  });
+
+  test("rejects a mapping when this field has no type", async () => {
+    stubMonitorFields([
+      { name: "Vendor", customFieldType: CustomFieldType.Text },
+    ]);
+
+    await expect(
+      validateCustomFieldMappingOnCreate({
+        definitionModelType: AlertCustomField,
+        createBy: buildCreateBy({
+          name: "Vendor",
+          mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+          mapFromCustomFieldName: "Vendor",
+        }),
+      }),
+    ).rejects.toThrow(/field type/);
+  });
+});
+
+describe("validateCustomFieldMappingOnUpdate", () => {
+  type BuildUpdateByFunction = (data: JSONObject) => UpdateBy<AlertCustomField>;
+
+  const buildUpdateBy: BuildUpdateByFunction = (
+    data: JSONObject,
+  ): UpdateBy<AlertCustomField> => {
+    return {
+      query: { _id: "abc" },
+      data: data,
+      props: { isRoot: true, tenantId: PROJECT_ID },
+      limit: 1,
+      skip: 0,
+    } as unknown as UpdateBy<AlertCustomField>;
+  };
+
+  type StubStoredDefinitionFunction = (
+    definition: Partial<AlertCustomField>,
+  ) => void;
+
+  const stubStoredDefinition: StubStoredDefinitionFunction = (
+    definition: Partial<AlertCustomField>,
+  ): void => {
+    jest.spyOn(AlertCustomFieldService, "findBy").mockResolvedValue([
+      Object.assign(new AlertCustomField(), {
+        projectId: PROJECT_ID,
+        ...definition,
+      }),
+    ] as never);
+  };
+
+  /*
+   * The payload is a PARTIAL. Changing only the source field name still has to
+   * be checked against the type already stored on the row.
+   */
+  test("checks a partial payload against the values already on the row", async () => {
+    stubStoredDefinition({
+      customFieldType: CustomFieldType.Text,
+      mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+      mapFromCustomFieldName: "Vendor",
+    });
+    stubMonitorFields([
+      { name: "Supplier", customFieldType: CustomFieldType.Number },
+    ]);
+
+    await expect(
+      validateCustomFieldMappingOnUpdate({
+        definitionModelType: AlertCustomField,
+        definitionService: AlertCustomFieldService,
+        updateBy: buildUpdateBy({ mapFromCustomFieldName: "Supplier" }),
+      }),
+    ).rejects.toThrow(/same type/);
+  });
+
+  /*
+   * A mapping that was valid when it was saved can be invalidated from this
+   * side later, by narrowing the target's own option list.
+   */
+  test("rejects narrowing this field's options below what the source can hold", async () => {
+    stubStoredDefinition({
+      customFieldType: CustomFieldType.Dropdown,
+      dropdownOptions: "Acme\nGlobex",
+      mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+      mapFromCustomFieldName: "Vendor",
+    });
+    stubMonitorFields([
+      {
+        name: "Vendor",
+        customFieldType: CustomFieldType.Dropdown,
+        dropdownOptions: "Acme\nGlobex",
+      },
+    ]);
+
+    await expect(
+      validateCustomFieldMappingOnUpdate({
+        definitionModelType: AlertCustomField,
+        definitionService: AlertCustomFieldService,
+        updateBy: buildUpdateBy({ dropdownOptions: "Acme" }),
+      }),
+    ).rejects.toThrow(/Globex/);
+  });
+
+  test("rejects naming a field to copy on a row with no source resource", async () => {
+    stubStoredDefinition({ customFieldType: CustomFieldType.Text });
+
+    await expect(
+      validateCustomFieldMappingOnUpdate({
+        definitionModelType: AlertCustomField,
+        definitionService: AlertCustomFieldService,
+        updateBy: buildUpdateBy({ mapFromCustomFieldName: "Vendor" }),
+      }),
+    ).rejects.toThrow(/Choose both/);
+  });
+
+  test("ignores an update that cannot affect the mapping", async () => {
+    const findStored: jest.SpyInstance = jest
+      .spyOn(AlertCustomFieldService, "findBy")
+      .mockResolvedValue([] as never);
+
+    await validateCustomFieldMappingOnUpdate({
+      definitionModelType: AlertCustomField,
+      definitionService: AlertCustomFieldService,
+      updateBy: buildUpdateBy({ description: "A new description" }),
+    });
+
+    expect(findStored).not.toHaveBeenCalled();
+  });
+
+  test("accepts turning a mapping off", async () => {
+    stubStoredDefinition({
+      customFieldType: CustomFieldType.Text,
+      mapFromResourceType: CustomFieldMappingSourceResource.Monitor,
+      mapFromCustomFieldName: "Vendor",
+    });
+    const findMonitorFields: jest.SpyInstance = jest
+      .spyOn(MonitorCustomFieldService, "findBy")
+      .mockResolvedValue([] as never);
+
+    const updateBy: UpdateBy<AlertCustomField> = buildUpdateBy({
+      mapFromResourceType: "",
+    });
+
+    await expect(
+      validateCustomFieldMappingOnUpdate({
+        definitionModelType: AlertCustomField,
+        definitionService: AlertCustomFieldService,
+        updateBy: updateBy,
+      }),
+    ).resolves.toBeUndefined();
+
+    expect((updateBy.data as JSONObject)["mapFromResourceType"]).toBeNull();
+    expect((updateBy.data as JSONObject)["mapFromCustomFieldName"]).toBeNull();
+    expect(findMonitorFields).not.toHaveBeenCalled();
+  });
+});

package/Tests/Server/Utils/Dashboard/PublicDashboardResourceListPolicy.test.ts

@@ -3,6 +3,7 @@ import PublicDashboardResourceListPolicy, {
 } from "../../../../Server/Utils/Dashboard/PublicDashboardResourceListPolicy";
 import InBetween from "../../../../Types/BaseDatabase/InBetween";
 import Includes from "../../../../Types/BaseDatabase/Includes";
+import IncludesAnyOfGroups from "../../../../Types/BaseDatabase/IncludesAnyOfGroups";
 import Search from "../../../../Types/BaseDatabase/Search";
 import SortOrder from "../../../../Types/BaseDatabase/SortOrder";
 import { LIMIT_PER_PROJECT } from "../../../../Types/Database/LimitMax";
@@ -1038,6 +1039,219 @@ describe("PublicDashboardResourceListPolicy", () => {
     });
   });
 
+  describe("monitor project label variables", () => {
+    const firstLabelId: string = ObjectID.generate().toString();
+    const secondLabelId: string = ObjectID.generate().toString();
+    const fixedLabelId: string = ObjectID.generate().toString();
+    const labelVariable: JSONObject = {
+      id: "unit",
+      name: "UNIT",
+      type: DashboardVariableType.ProjectLabel,
+      labelOptions: [
+        { label: "Payments", value: firstLabelId },
+        { label: "Support", value: secondLabelId },
+      ],
+      defaultValue: firstLabelId,
+    };
+
+    it("filters by the saved variable's default when no selection was sent", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.MonitorList,
+        argumentsObject: { labelVariableId: "unit" },
+        storedVariables: [labelVariable],
+      });
+
+      expect(result.query).toEqual({ labels: new Includes([firstLabelId]) });
+    });
+
+    it("uses the selected label ID while retaining the saved widget filters", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.MonitorList,
+        argumentsObject: {
+          labelVariableId: "unit",
+          statusFilter: "operational",
+          monitorTypes: ["Ping"],
+          monitorStatusIds: ["status"],
+          maxRows: 7,
+        },
+        storedVariables: [labelVariable],
+        requestedVariables: [{ id: "unit", selectedValue: secondLabelId }],
+      });
+
+      expect(result.query).toEqual({
+        labels: new Includes([secondLabelId]),
+        currentMonitorStatus: { isOperationalState: true },
+        monitorType: new Includes(["Ping"]),
+        currentMonitorStatusId: new Includes(["status"]),
+      });
+      expect(result.limit).toBe(7);
+      expect(result.sort).toEqual({ name: SortOrder.Ascending });
+      expect(result.select).toEqual({
+        _id: true,
+        name: true,
+        monitorType: true,
+        currentMonitorStatus: { name: true, color: true },
+      });
+    });
+
+    it("requires both a fixed label group and the selected variable group", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.MonitorList,
+        argumentsObject: {
+          labelVariableId: "unit",
+          labelIds: [fixedLabelId],
+        },
+        storedVariables: [labelVariable],
+        requestedVariables: [{ id: "unit", selectedValue: secondLabelId }],
+      });
+
+      expect(result.query["labels"]).toEqual(
+        new IncludesAnyOfGroups([[fixedLabelId], [secondLabelId]]),
+      );
+    });
+
+    it("lets All clear only the variable filter and preserves fixed labels", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.MonitorList,
+        argumentsObject: {
+          labelVariableId: "unit",
+          labelIds: [fixedLabelId],
+        },
+        storedVariables: [labelVariable],
+        requestedVariables: [{ id: "unit", selectedValue: "" }],
+      });
+
+      expect(result.query["labels"]).toEqual(new Includes([fixedLabelId]));
+    });
+
+    it("leaves the label filter absent when All is selected without fixed labels", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.MonitorList,
+        argumentsObject: { labelVariableId: "unit" },
+        storedVariables: [labelVariable],
+        requestedVariables: [{ id: "unit", selectedValue: "" }],
+      });
+
+      expect(result.query["labels"]).toBeUndefined();
+    });
+
+    it("matches either selected label for a multi-select", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.MonitorList,
+        argumentsObject: { labelVariableId: "unit" },
+        storedVariables: [{ ...labelVariable, isMultiSelect: true }],
+        requestedVariables: [
+          { id: "unit", selectedValues: [firstLabelId, secondLabelId] },
+        ],
+      });
+
+      expect(result.query["labels"]).toEqual(
+        new Includes([firstLabelId, secondLabelId]),
+      );
+    });
+
+    it("treats an empty multi-select as All even when a default or stale scalar exists", () => {
+      for (const requestedVariables of [
+        [],
+        [{ id: "unit", selectedValue: firstLabelId, selectedValues: [] }],
+      ]) {
+        const result: PublicDashboardResourceListPolicyResult = build({
+          componentType: DashboardComponentType.MonitorList,
+          argumentsObject: {
+            labelVariableId: "unit",
+            labelIds: [fixedLabelId],
+          },
+          storedVariables: [{ ...labelVariable, isMultiSelect: true }],
+          requestedVariables,
+        });
+
+        expect(result.query["labels"]).toEqual(new Includes([fixedLabelId]));
+      }
+    });
+
+    it("ignores stale multi-select values for a saved single-select", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.MonitorList,
+        argumentsObject: { labelVariableId: "unit" },
+        storedVariables: [labelVariable],
+        requestedVariables: [
+          {
+            id: "unit",
+            selectedValue: firstLabelId,
+            selectedValues: [secondLabelId],
+          },
+        ],
+      });
+
+      expect(result.query["labels"]).toEqual(new Includes([firstLabelId]));
+    });
+
+    it("does not apply a label variable to an unbound widget", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.MonitorList,
+        argumentsObject: { labelIds: [fixedLabelId] },
+        storedVariables: [labelVariable],
+        requestedVariables: [{ id: "unit", selectedValue: secondLabelId }],
+      });
+
+      expect(result.query["labels"]).toEqual(new Includes([fixedLabelId]));
+    });
+
+    it("rejects a selection that is no longer among the published choices", () => {
+      expect(() => {
+        return build({
+          componentType: DashboardComponentType.MonitorList,
+          argumentsObject: { labelVariableId: "unit" },
+          storedVariables: [labelVariable],
+          requestedVariables: [
+            { id: "unit", selectedValue: ObjectID.generate().toString() },
+          ],
+        });
+      }).toThrow(BadDataException);
+    });
+
+    it("rejects a missing or incompatible saved variable binding", () => {
+      for (const storedVariables of [
+        [],
+        [
+          {
+            id: "unit",
+            name: "UNIT",
+            type: DashboardVariableType.TelemetryAttribute,
+            attributeKey: "unit",
+          },
+        ],
+      ]) {
+        expect(() => {
+          return build({
+            componentType: DashboardComponentType.MonitorList,
+            argumentsObject: { labelVariableId: "unit" },
+            storedVariables,
+          });
+        }).toThrow(BadDataException);
+      }
+    });
+
+    it("rejects malformed saved label choices", () => {
+      for (const labelOptions of [
+        null,
+        "Payments",
+        [null],
+        [{ value: firstLabelId }],
+        [{ label: "Payments", value: 42 }],
+        [{ label: "", value: firstLabelId }],
+      ]) {
+        expect(() => {
+          return build({
+            componentType: DashboardComponentType.MonitorList,
+            argumentsObject: { labelVariableId: "unit" },
+            storedVariables: [{ ...labelVariable, labelOptions }],
+          });
+        }).toThrow(BadDataException);
+      }
+    });
+  });
+
   describe("fixed limits and malformed widgets", () => {
     it("clamps stored list and map limits to the project ceiling", () => {
       expect(