@oneuptime/common 12.0.6 → 12.0.8

package/Tests/Utils/Schema/ModelSchema.test.ts

@@ -0,0 +1,268 @@
+import { ModelSchema } from "../../../Utils/Schema/ModelSchema";
+import Zod from "../../../Utils/Schema/Zod";
+import {
+  getTableColumns,
+  TableColumnMetadata,
+} from "../../../Types/Database/TableColumn";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import Dictionary from "../../../Types/Dictionary";
+import DatabaseBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Label from "../../../Models/DatabaseModels/Label";
+import ApiKey from "../../../Models/DatabaseModels/ApiKey";
+import Team from "../../../Models/DatabaseModels/Team";
+import ShortLink from "../../../Models/DatabaseModels/ShortLink";
+import MonitorGroup from "../../../Models/DatabaseModels/MonitorGroup";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+
+/*
+ * Unit tests for ModelSchema — the Zod schema generator behind the public API
+ * (OpenAPI spec, request validation, and the Terraform provider generator) for
+ * every Postgres-backed database model.
+ *
+ * The generator is pure: it reads TypeORM column metadata and per-column
+ * access control off a freshly instantiated model, so no database connection is
+ * needed. These tests pin down the create/update/delete/select/sort/group-by
+ * contracts that API consumers depend on.
+ */
+
+type ModelCtor = new () => DatabaseBaseModel;
+
+// A curated set of small, stable models spanning different column shapes.
+const SAMPLE_MODELS: Array<ModelCtor> = [
+  Label,
+  ApiKey,
+  Team,
+  ShortLink,
+  MonitorGroup,
+  StatusPage,
+  Incident,
+];
+
+// Column types ModelSchema.getSortableTypes() considers sortable.
+const SORTABLE_TYPES: Array<TableColumnType> = [
+  TableColumnType.VeryLongText,
+  TableColumnType.Slug,
+  TableColumnType.ShortText,
+  TableColumnType.LongText,
+  TableColumnType.Number,
+  TableColumnType.Date,
+  TableColumnType.Boolean,
+  TableColumnType.Description,
+  TableColumnType.ObjectID,
+];
+
+const CREATE_EXCLUDED_FIELDS: Array<string> = [
+  "_id",
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "version",
+];
+
+const UPDATE_EXCLUDED_FIELDS: Array<string> = [
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "version",
+];
+
+const isZodObject: (schema: unknown) => boolean = (
+  schema: unknown,
+): boolean => {
+  return schema instanceof Zod.ZodObject;
+};
+
+const shapeKeys: (schema: any) => Array<string> = (
+  schema: any,
+): Array<string> => {
+  return Object.keys(schema.shape);
+};
+
+describe("ModelSchema (Postgres)", () => {
+  describe("getModelSchema / getReadModelSchema", () => {
+    test("returns a non-empty ZodObject for a real model", () => {
+      const schema: any = ModelSchema.getModelSchema({ modelType: Label });
+
+      expect(isZodObject(schema)).toBe(true);
+      expect(shapeKeys(schema).length).toBeGreaterThan(0);
+    });
+
+    test("excludes Entity (relation) columns from the schema", () => {
+      const model: Label = new Label();
+      const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+      const schema: any = ModelSchema.getModelSchema({ modelType: Label });
+      const keys: Array<string> = shapeKeys(schema);
+
+      for (const key in columns) {
+        const column: TableColumnMetadata | undefined = columns[key];
+        if (column && column.type === TableColumnType.Entity) {
+          expect(keys).not.toContain(key);
+        }
+      }
+    });
+
+    test("only includes columns that grant read access", () => {
+      const model: Label = new Label();
+      const accessControl: any = model.getColumnAccessControlForAllColumns();
+      const schema: any = ModelSchema.getModelSchema({ modelType: Label });
+
+      for (const key of shapeKeys(schema)) {
+        const control: any = accessControl[key];
+        /*
+         * Columns with declared access control must expose read permissions;
+         * columns without any declared control are allowed through.
+         */
+        if (control) {
+          expect(control.read.length).toBeGreaterThan(0);
+        }
+      }
+    });
+
+    test("builds read schemas for every sample model", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        expect(isZodObject(ModelSchema.getModelSchema({ modelType }))).toBe(
+          true,
+        );
+        expect(isZodObject(ModelSchema.getReadModelSchema({ modelType }))).toBe(
+          true,
+        );
+      }
+    });
+  });
+
+  describe("getCreateModelSchema", () => {
+    test("excludes auto-generated system fields", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getCreateModelSchema({ modelType });
+        const keys: Array<string> = shapeKeys(schema);
+        for (const excluded of CREATE_EXCLUDED_FIELDS) {
+          expect(keys).not.toContain(excluded);
+        }
+      }
+    });
+
+    test("produces the same fields with and without OpenAPI metadata", () => {
+      const withOpenApi: any = ModelSchema.getCreateModelSchema({
+        modelType: Label,
+      });
+      const withoutOpenApi: any = ModelSchema.getCreateModelSchema({
+        modelType: Label,
+        disableOpenApiSchema: true,
+      });
+
+      expect(isZodObject(withoutOpenApi)).toBe(true);
+      expect(shapeKeys(withoutOpenApi).sort()).toEqual(
+        shapeKeys(withOpenApi).sort(),
+      );
+    });
+  });
+
+  describe("getUpdateModelSchema", () => {
+    test("excludes immutable audit fields but keeps _id", () => {
+      const schema: any = ModelSchema.getUpdateModelSchema({
+        modelType: Label,
+      });
+      const keys: Array<string> = shapeKeys(schema);
+
+      for (const excluded of UPDATE_EXCLUDED_FIELDS) {
+        expect(keys).not.toContain(excluded);
+      }
+    });
+
+    test("treats every field as optional (empty patch is valid)", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getUpdateModelSchema({ modelType });
+        expect(schema.safeParse({}).success).toBe(true);
+      }
+    });
+  });
+
+  describe("getDeleteModelSchema", () => {
+    test("only exposes the identifier field", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getDeleteModelSchema({ modelType });
+        expect(shapeKeys(schema)).toEqual(["_id"]);
+      }
+    });
+  });
+
+  describe("getSelectModelSchema", () => {
+    test("marks fields as optional booleans and rejects other types", () => {
+      const schema: any = ModelSchema.getSelectModelSchema({
+        modelType: Label,
+      });
+      const keys: Array<string> = shapeKeys(schema);
+      const someKey: string = keys[0]!;
+
+      expect(keys.length).toBeGreaterThan(0);
+      expect(schema.safeParse({}).success).toBe(true);
+      expect(schema.safeParse({ [someKey]: true }).success).toBe(true);
+      expect(schema.safeParse({ [someKey]: "select-me" }).success).toBe(false);
+    });
+
+    test("builds a select schema for every sample model", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        expect(
+          isZodObject(ModelSchema.getSelectModelSchema({ modelType })),
+        ).toBe(true);
+      }
+    });
+  });
+
+  describe("getSortModelSchema", () => {
+    test("includes only sortable column types", () => {
+      const model: Label = new Label();
+      const columns: Dictionary<TableColumnMetadata> = getTableColumns(model);
+      const schema: any = ModelSchema.getSortModelSchema({ modelType: Label });
+      const keys: Array<string> = shapeKeys(schema);
+
+      for (const key in columns) {
+        const column: TableColumnMetadata | undefined = columns[key];
+        if (!column) {
+          continue;
+        }
+        if (SORTABLE_TYPES.includes(column.type)) {
+          expect(keys).toContain(key);
+        } else {
+          expect(keys).not.toContain(key);
+        }
+      }
+    });
+
+    test("accepts only ASC/DESC values", () => {
+      const schema: any = ModelSchema.getSortModelSchema({ modelType: Label });
+      const key: string = shapeKeys(schema)[0]!;
+
+      expect(schema.safeParse({}).success).toBe(true);
+      expect(schema.safeParse({ [key]: SortOrder.Ascending }).success).toBe(
+        true,
+      );
+      expect(schema.safeParse({ [key]: SortOrder.Descending }).success).toBe(
+        true,
+      );
+      expect(schema.safeParse({ [key]: "RANDOM" }).success).toBe(false);
+    });
+  });
+
+  describe("getGroupByModelSchema", () => {
+    test("builds a group-by schema and accepts an empty object", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getGroupByModelSchema({ modelType });
+        expect(isZodObject(schema)).toBe(true);
+        expect(schema.safeParse({}).success).toBe(true);
+      }
+    });
+  });
+
+  describe("getQueryModelSchema", () => {
+    test("builds a query schema that accepts an empty query", () => {
+      for (const modelType of SAMPLE_MODELS) {
+        const schema: any = ModelSchema.getQueryModelSchema({ modelType });
+        expect(isZodObject(schema)).toBe(true);
+        expect(schema.safeParse({}).success).toBe(true);
+      }
+    });
+  });
+});

package/Tests/Utils/Telemetry/EntityKeyNonTelemetry.test.ts

@@ -0,0 +1,193 @@
+import {
+  computeEntityKey,
+  INVENTORY_ENTITY_IDENTITY_ATTRIBUTE,
+  keyForInventoryEntity,
+  keyForManualEntity,
+  MANUAL_ENTITY_IDENTITY_ATTRIBUTE,
+} from "../../../Utils/Telemetry/EntityKey";
+import EntityType from "../../../Types/Telemetry/EntityType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Identity for the two entity flavours that never pass through ingest:
+ * manually registered CIs and rows mirrored from OneUptime's inventory
+ * tables. Neither has an ingest-side resolver to byte-match, so the only
+ * things that must hold are the ones tested here — determinism, tenant and
+ * type separation, and the specific choice of what each keys on (a manual CI
+ * on its name, an inventory mirror on its owning row's id).
+ *
+ * The consequence of getting these wrong is duplicate registry rows that
+ * both look correct, so each property is pinned rather than assumed.
+ */
+
+const PROJECT: string = "proj1";
+const OTHER_PROJECT: string = "proj2";
+const RESOURCE_ID: string = "6f2e5c1a-0b3d-4e5f-8a9b-1c2d3e4f5a6b";
+
+describe("keyForManualEntity", () => {
+  test("is deterministic", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Stripe API"),
+    ).toBe(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Stripe API"),
+    );
+  });
+
+  test("is a 16-char lowercase hex key, like every other entity key", () => {
+    const key: string = keyForManualEntity(
+      PROJECT,
+      EntityType.ExternalService,
+      "Stripe API",
+    );
+    expect(key).toMatch(/^[0-9a-f]{16}$/);
+  });
+
+  test("canonicalizes the name, so casing and padding do not fork identity", () => {
+    const canonical: string = keyForManualEntity(
+      PROJECT,
+      EntityType.ExternalService,
+      "Stripe API",
+    );
+
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "  stripe api "),
+    ).toBe(canonical);
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "STRIPE API"),
+    ).toBe(canonical);
+  });
+
+  test("separates tenants", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Stripe API"),
+    ).not.toBe(
+      keyForManualEntity(
+        OTHER_PROJECT,
+        EntityType.ExternalService,
+        "Stripe API",
+      ),
+    );
+  });
+
+  test("separates types, so one name can exist as two kinds of thing", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "payments"),
+    ).not.toBe(
+      keyForManualEntity(PROJECT, EntityType.ExternalDatabase, "payments"),
+    );
+  });
+
+  test("distinct names within a type get distinct keys", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Stripe API"),
+    ).not.toBe(
+      keyForManualEntity(PROJECT, EntityType.ExternalService, "Adyen API"),
+    );
+  });
+
+  test("matches computeEntityKey over the documented identity attribute", () => {
+    expect(
+      keyForManualEntity(PROJECT, EntityType.Appliance, "Rack PDU 3"),
+    ).toBe(
+      computeEntityKey({
+        projectId: PROJECT,
+        entityType: EntityType.Appliance,
+        identifyingAttributes: {
+          [MANUAL_ENTITY_IDENTITY_ATTRIBUTE]: "rack pdu 3",
+        },
+      }),
+    );
+  });
+});
+
+describe("keyForInventoryEntity", () => {
+  test("is deterministic", () => {
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.NetworkDevice, RESOURCE_ID),
+    ).toBe(
+      keyForInventoryEntity(PROJECT, EntityType.NetworkDevice, RESOURCE_ID),
+    );
+  });
+
+  test("keys on the owning row id, so renaming the row keeps its identity", () => {
+    /*
+     * This is the whole reason inventory mirrors key on the id rather than
+     * the name: a rename must update the existing registry row, not orphan
+     * it and mint a second one alongside.
+     */
+    const key: string = keyForInventoryEntity(
+      PROJECT,
+      EntityType.NetworkDevice,
+      RESOURCE_ID,
+    );
+
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.NetworkDevice, RESOURCE_ID),
+    ).toBe(key);
+  });
+
+  test("separates tenants and types", () => {
+    const key: string = keyForInventoryEntity(
+      PROJECT,
+      EntityType.NetworkDevice,
+      RESOURCE_ID,
+    );
+
+    expect(
+      keyForInventoryEntity(
+        OTHER_PROJECT,
+        EntityType.NetworkDevice,
+        RESOURCE_ID,
+      ),
+    ).not.toBe(key);
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.IoTDevice, RESOURCE_ID),
+    ).not.toBe(key);
+  });
+
+  test("distinct rows get distinct keys", () => {
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.NetworkDevice, RESOURCE_ID),
+    ).not.toBe(
+      keyForInventoryEntity(
+        PROJECT,
+        EntityType.NetworkDevice,
+        "11111111-2222-3333-4444-555555555555",
+      ),
+    );
+  });
+
+  test("matches computeEntityKey over the documented identity attribute", () => {
+    expect(
+      keyForInventoryEntity(PROJECT, EntityType.CloudResource, RESOURCE_ID),
+    ).toBe(
+      computeEntityKey({
+        projectId: PROJECT,
+        entityType: EntityType.CloudResource,
+        identifyingAttributes: {
+          [INVENTORY_ENTITY_IDENTITY_ATTRIBUTE]: RESOURCE_ID,
+        },
+      }),
+    );
+  });
+});
+
+describe("manual and inventory identities do not collide", () => {
+  test("the two attributes are distinct", () => {
+    expect(MANUAL_ENTITY_IDENTITY_ATTRIBUTE).not.toBe(
+      INVENTORY_ENTITY_IDENTITY_ATTRIBUTE,
+    );
+  });
+
+  test("same project, same type, same literal value still key differently", () => {
+    /*
+     * A manual CI literally named after a resource id would otherwise
+     * collide with the mirror of that resource.
+     */
+    expect(
+      keyForManualEntity(PROJECT, EntityType.Appliance, RESOURCE_ID),
+    ).not.toBe(
+      keyForInventoryEntity(PROJECT, EntityType.Appliance, RESOURCE_ID),
+    );
+  });
+});

package/Tests/Utils/Telemetry/SavedViewFilters.test.ts

@@ -0,0 +1,246 @@
+import JSONFunctions from "../../../Types/JSONFunctions";
+import TelemetrySavedViewState from "../../../Types/Telemetry/TelemetrySavedViewState";
+import { JSONObject } from "../../../Types/JSON";
+import {
+  readSavedViewFilters,
+  SavedViewFilterTuple,
+} from "../../../Utils/Telemetry/SavedViewFilters";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Facet filters are stored as [facetKey, value] tuples inside a JSON column,
+ * and for a while the serializer rewrote every one of them into
+ * { "0": facetKey, "1": value }. Those rows are still in the database, so the
+ * explorers cannot destructure saved filters directly — a single bad row used
+ * to take the whole Traces page down with
+ * "TypeError: (destructured parameter) is not iterable".
+ *
+ * These tests cover both shapes and the junk in between.
+ */
+
+// The shape a pre-fix serializer left in the database.
+const LEGACY_CORRUPTED_FILTERS: unknown = [
+  { "0": "primaryEntityId", "1": "6512f1a0a1b2c3d4e5f60718" },
+  { "0": "attributes.http.method", "1": "GET" },
+];
+
+describe("readSavedViewFilters", () => {
+  describe("Well-formed saved state", () => {
+    test("Reads tuples that were stored correctly", () => {
+      expect(
+        readSavedViewFilters([
+          ["service", "api"],
+          ["status", "error"],
+        ]),
+      ).toEqual([
+        ["service", "api"],
+        ["status", "error"],
+      ]);
+    });
+
+    test("Reads a single tuple", () => {
+      expect(readSavedViewFilters([["service", "api"]])).toEqual([
+        ["service", "api"],
+      ]);
+    });
+
+    test("Returns an empty list for an empty list", () => {
+      expect(readSavedViewFilters([])).toEqual([]);
+    });
+
+    test("Keeps a filter whose value is deliberately the empty string", () => {
+      expect(readSavedViewFilters([["statusMessage", ""]])).toEqual([
+        ["statusMessage", ""],
+      ]);
+    });
+
+    test("Ignores anything beyond the first two elements of a tuple", () => {
+      expect(
+        readSavedViewFilters([["service", "api", "extra", "junk"]]),
+      ).toEqual([["service", "api"]]);
+    });
+
+    test("Preserves order", () => {
+      expect(
+        readSavedViewFilters([
+          ["c", "3"],
+          ["a", "1"],
+          ["b", "2"],
+        ]),
+      ).toEqual([
+        ["c", "3"],
+        ["a", "1"],
+        ["b", "2"],
+      ]);
+    });
+
+    test("Returns real arrays, so callers can destructure them", () => {
+      const filters: Array<SavedViewFilterTuple> = readSavedViewFilters([
+        ["service", "api"],
+      ]);
+
+      const read: Array<string> = filters.map(
+        ([facetKey, value]: SavedViewFilterTuple): string => {
+          return `${facetKey}:${value}`;
+        },
+      );
+
+      expect(read).toEqual(["service:api"]);
+    });
+  });
+
+  describe("Legacy rows corrupted by the old serializer", () => {
+    test("Reads { '0': key, '1': value } back into a tuple", () => {
+      expect(readSavedViewFilters(LEGACY_CORRUPTED_FILTERS)).toEqual([
+        ["primaryEntityId", "6512f1a0a1b2c3d4e5f60718"],
+        ["attributes.http.method", "GET"],
+      ]);
+    });
+
+    test("A healed legacy row is destructurable", () => {
+      const filters: Array<SavedViewFilterTuple> = readSavedViewFilters(
+        LEGACY_CORRUPTED_FILTERS,
+      );
+
+      expect(() => {
+        return filters.map(([facetKey]: SavedViewFilterTuple): string => {
+          return facetKey;
+        });
+      }).not.toThrow();
+    });
+
+    test("Reads a list that mixes healed and correct rows", () => {
+      expect(
+        readSavedViewFilters([
+          { "0": "service", "1": "api" },
+          ["status", "error"],
+        ]),
+      ).toEqual([
+        ["service", "api"],
+        ["status", "error"],
+      ]);
+    });
+
+    test("Heals exactly what the old serializer produced, end to end", () => {
+      /*
+       * Reproduce the corruption the way it actually happened — through the
+       * pre-fix serializer — rather than hand-writing the broken shape.
+       */
+      const corrupted: JSONObject = {
+        filters: [
+          { "0": "service", "1": "api" },
+          { "0": "status", "1": "error" },
+        ],
+      };
+
+      expect(readSavedViewFilters(corrupted["filters"])).toEqual([
+        ["service", "api"],
+        ["status", "error"],
+      ]);
+    });
+  });
+
+  describe("Malformed saved state never throws", () => {
+    test("Returns an empty list for undefined, null and non-arrays", () => {
+      expect(readSavedViewFilters(undefined)).toEqual([]);
+      expect(readSavedViewFilters(null)).toEqual([]);
+      expect(readSavedViewFilters("service:api")).toEqual([]);
+      expect(readSavedViewFilters(42)).toEqual([]);
+      expect(readSavedViewFilters(true)).toEqual([]);
+      expect(readSavedViewFilters({})).toEqual([]);
+      expect(readSavedViewFilters({ service: "api" })).toEqual([]);
+    });
+
+    test("Drops entries that are not tuple-shaped at all", () => {
+      expect(
+        readSavedViewFilters([
+          "service:api",
+          42,
+          null,
+          undefined,
+          true,
+          ["status", "error"],
+        ]),
+      ).toEqual([["status", "error"]]);
+    });
+
+    test("Drops entries with no usable facet key", () => {
+      expect(
+        readSavedViewFilters([
+          [],
+          ["", "api"],
+          [null, "api"],
+          [{ nested: true }, "api"],
+          ["service", "api"],
+        ]),
+      ).toEqual([["service", "api"]]);
+    });
+
+    test("Falls back to an empty value when the stored value is unusable", () => {
+      expect(readSavedViewFilters([["service", null]])).toEqual([
+        ["service", ""],
+      ]);
+      expect(readSavedViewFilters([["service"]])).toEqual([["service", ""]]);
+      expect(readSavedViewFilters([["service", { nested: true }]])).toEqual([
+        ["service", ""],
+      ]);
+      expect(readSavedViewFilters([["service", ["a"]]])).toEqual([
+        ["service", ""],
+      ]);
+    });
+
+    test("Stringifies values that came back as numbers or booleans", () => {
+      expect(
+        readSavedViewFilters([
+          ["duration", 500],
+          ["hasException", true],
+        ]),
+      ).toEqual([
+        ["duration", "500"],
+        ["hasException", "true"],
+      ]);
+    });
+
+    test("Drops non-finite numeric values rather than writing 'NaN' into a chip", () => {
+      expect(readSavedViewFilters([["duration", NaN]])).toEqual([
+        ["duration", ""],
+      ]);
+      expect(readSavedViewFilters([["duration", Infinity]])).toEqual([
+        ["duration", ""],
+      ]);
+    });
+
+    test("Reads a numeric facet key stored as a number", () => {
+      expect(readSavedViewFilters([[7, "api"]])).toEqual([["7", "api"]]);
+    });
+  });
+
+  describe("Round trip through the serializer that stores the view", () => {
+    test("Filters written by the fixed serializer read straight back", () => {
+      const state: TelemetrySavedViewState = {
+        search: "status:error",
+        filters: [
+          ["service", "api"],
+          ["attributes.http.method", "GET"],
+        ],
+        pageSize: 50,
+      };
+
+      const stored: JSONObject = JSONFunctions.deserialize(
+        JSON.parse(
+          JSON.stringify(JSONFunctions.serialize(state as JSONObject)),
+        ),
+      );
+
+      expect(readSavedViewFilters(stored["filters"])).toEqual(state.filters);
+    });
+
+    test("A view with no filters at all reads as no filters", () => {
+      const state: TelemetrySavedViewState = { search: "status:error" };
+
+      const stored: JSONObject = JSONFunctions.serialize(state as JSONObject);
+
+      expect(readSavedViewFilters(stored["filters"])).toEqual([]);
+    });
+  });
+});