@oneuptime/common 12.0.7 → 12.0.8

package/Tests/Types/SerializableObjectDictionaryImportCycle.test.ts

@@ -0,0 +1,197 @@
+/*
+ * Importing an operator class FIRST is the whole point of this file.
+ *
+ * Includes, IncludesAll and IncludesNone import JSONFunctions (their fromJSON
+ * deserializes the values inside them), and JSONFunctions imports the
+ * dictionary that holds them — a cycle. While the dictionary was a plain
+ * object literal, whichever side of the cycle initialized second captured the
+ * other as `undefined`, so `{"_type":"Includes","value":[...]}` came back out
+ * of JSONFunctions.deserialize as a plain object instead of an Includes. A
+ * plain object reaching TypeORM is a silently wrong query rather than an
+ * error, which is exactly the kind of failure worth pinning down.
+ *
+ * Jest gives each test file its own module registry, so this file's import
+ * order genuinely reproduces the bad ordering.
+ */
+
+import Includes from "../../Types/BaseDatabase/Includes";
+import IncludesAll from "../../Types/BaseDatabase/IncludesAll";
+import IncludesNone from "../../Types/BaseDatabase/IncludesNone";
+import EqualTo from "../../Types/BaseDatabase/EqualTo";
+import EqualToOrNull from "../../Types/BaseDatabase/EqualToOrNull";
+import GreaterThan from "../../Types/BaseDatabase/GreaterThan";
+import GreaterThanOrEqual from "../../Types/BaseDatabase/GreaterThanOrEqual";
+import GreaterThanOrNull from "../../Types/BaseDatabase/GreaterThanOrNull";
+import InBetween from "../../Types/BaseDatabase/InBetween";
+import IsNull from "../../Types/BaseDatabase/IsNull";
+import LessThan from "../../Types/BaseDatabase/LessThan";
+import LessThanOrEqual from "../../Types/BaseDatabase/LessThanOrEqual";
+import LessThanOrNull from "../../Types/BaseDatabase/LessThanOrNull";
+import NotContains from "../../Types/BaseDatabase/NotContains";
+import NotEqual from "../../Types/BaseDatabase/NotEqual";
+import NotNull from "../../Types/BaseDatabase/NotNull";
+import Search from "../../Types/BaseDatabase/Search";
+import StartsWith from "../../Types/BaseDatabase/StartsWith";
+import EndsWith from "../../Types/BaseDatabase/EndsWith";
+import SerializableObjectDictionary from "../../Types/SerializableObjectDictionary";
+import JSONFunctions from "../../Types/JSONFunctions";
+import { JSONObject, ObjectType } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import { describe, expect, test } from "@jest/globals";
+
+describe("SerializableObjectDictionary registration", () => {
+  /*
+   * The regression itself. These three sit on the cycle, and this file imports
+   * them before the dictionary — the order that used to leave them undefined.
+   */
+  test("the classes on the import cycle resolve", () => {
+    expect(SerializableObjectDictionary[ObjectType.Includes]).toBe(Includes);
+    expect(SerializableObjectDictionary[ObjectType.IncludesAll]).toBe(
+      IncludesAll,
+    );
+    expect(SerializableObjectDictionary[ObjectType.IncludesNone]).toBe(
+      IncludesNone,
+    );
+  });
+
+  test("each entry resolves to the class it names", () => {
+    expect(SerializableObjectDictionary[ObjectType.EqualTo]).toBe(EqualTo);
+    expect(SerializableObjectDictionary[ObjectType.NotEqual]).toBe(NotEqual);
+    expect(SerializableObjectDictionary[ObjectType.Search]).toBe(Search);
+    expect(SerializableObjectDictionary[ObjectType.GreaterThan]).toBe(
+      GreaterThan,
+    );
+    expect(SerializableObjectDictionary[ObjectType.IsNull]).toBe(IsNull);
+    expect(SerializableObjectDictionary[ObjectType.NotNull]).toBe(NotNull);
+  });
+
+  test("entries stay resolvable when read more than once", () => {
+    expect(SerializableObjectDictionary[ObjectType.Includes]).toBe(Includes);
+    expect(SerializableObjectDictionary[ObjectType.Includes]).toBe(Includes);
+  });
+
+  test("an unknown type resolves to nothing rather than throwing", () => {
+    expect(SerializableObjectDictionary["NotAThing"]).toBeUndefined();
+  });
+});
+
+type RoundTripFunction = (value: unknown) => unknown;
+
+/** JSON.stringify -> JSON.parse -> deserialize, exactly as a request does. */
+const roundTrip: RoundTripFunction = (value: unknown): unknown => {
+  const parsed: JSONObject = JSON.parse(JSON.stringify({ v: value }));
+
+  return (JSONFunctions.deserialize(parsed) as JSONObject)["v"];
+};
+
+describe("query operators survive a serialize/deserialize round trip", () => {
+  test("Includes keeps its class and its values", () => {
+    const result: unknown = roundTrip(new Includes(["x", "y"]));
+
+    expect(result).toBeInstanceOf(Includes);
+    expect((result as Includes).values).toEqual(["x", "y"]);
+  });
+
+  test("IncludesNone keeps its class and its values", () => {
+    const result: unknown = roundTrip(new IncludesNone(["x"]));
+
+    expect(result).toBeInstanceOf(IncludesNone);
+    expect((result as IncludesNone).values).toEqual(["x"]);
+  });
+
+  test("IncludesAll keeps its class and its values", () => {
+    const result: unknown = roundTrip(new IncludesAll(["x", "y"]));
+
+    expect(result).toBeInstanceOf(IncludesAll);
+  });
+
+  test("an empty membership list survives", () => {
+    const result: unknown = roundTrip(new Includes([]));
+
+    expect(result).toBeInstanceOf(Includes);
+    expect((result as Includes).values).toEqual([]);
+  });
+
+  test("ObjectIDs inside a membership list come back as ObjectIDs", () => {
+    const id: ObjectID = new ObjectID("11111111-1111-4111-8111-111111111111");
+    const result: unknown = roundTrip(new Includes([id]));
+
+    expect(result).toBeInstanceOf(Includes);
+    expect((result as Includes).values[0]).toBeInstanceOf(ObjectID);
+  });
+
+  test("the comparison operators keep their class and value", () => {
+    expect(roundTrip(new NotEqual<string>("a"))).toBeInstanceOf(NotEqual);
+    expect(roundTrip(new EqualTo<string>("a"))).toBeInstanceOf(EqualTo);
+    expect(roundTrip(new EqualToOrNull<string>("a"))).toBeInstanceOf(
+      EqualToOrNull,
+    );
+    expect(roundTrip(new GreaterThan<number>(1))).toBeInstanceOf(GreaterThan);
+    expect(roundTrip(new GreaterThanOrEqual<number>(1))).toBeInstanceOf(
+      GreaterThanOrEqual,
+    );
+    expect(roundTrip(new LessThan<number>(1))).toBeInstanceOf(LessThan);
+    expect(roundTrip(new LessThanOrEqual<number>(1))).toBeInstanceOf(
+      LessThanOrEqual,
+    );
+    expect(roundTrip(new GreaterThanOrNull<number>(1))).toBeInstanceOf(
+      GreaterThanOrNull,
+    );
+    expect(roundTrip(new LessThanOrNull<number>(1))).toBeInstanceOf(
+      LessThanOrNull,
+    );
+  });
+
+  test("the text operators keep their class", () => {
+    expect(roundTrip(new Search("a"))).toBeInstanceOf(Search);
+    expect(roundTrip(new NotContains("a"))).toBeInstanceOf(NotContains);
+    expect(roundTrip(new StartsWith("a"))).toBeInstanceOf(StartsWith);
+    expect(roundTrip(new EndsWith("a"))).toBeInstanceOf(EndsWith);
+  });
+
+  test("the null checks keep their class", () => {
+    expect(roundTrip(new IsNull())).toBeInstanceOf(IsNull);
+    expect(roundTrip(new NotNull())).toBeInstanceOf(NotNull);
+  });
+
+  test("InBetween keeps both of its bounds", () => {
+    const result: unknown = roundTrip(new InBetween<number>(1, 5));
+
+    expect(result).toBeInstanceOf(InBetween);
+    expect((result as InBetween<number>).startValue).toBe(1);
+    expect((result as InBetween<number>).endValue).toBe(5);
+  });
+
+  test("a numeric comparison keeps its number, not a string of it", () => {
+    const result: unknown = roundTrip(new GreaterThan<number>(42));
+
+    expect((result as GreaterThan<number>).value).toBe(42);
+  });
+
+  test("plain values are left exactly as they are", () => {
+    expect(roundTrip("plain")).toBe("plain");
+    expect(roundTrip(7)).toBe(7);
+    expect(roundTrip(true)).toBe(true);
+    expect(roundTrip(null)).toBeNull();
+  });
+
+  test("a whole query of mixed operators deserializes together", () => {
+    const query: JSONObject = JSON.parse(
+      JSON.stringify({
+        name: new Search("acme"),
+        tags: new Includes(["a", "b"]),
+        count: new GreaterThan<number>(3),
+        deletedAt: new IsNull(),
+        isEnabled: true,
+      }),
+    );
+
+    const result: JSONObject = JSONFunctions.deserialize(query) as JSONObject;
+
+    expect(result["name"]).toBeInstanceOf(Search);
+    expect(result["tags"]).toBeInstanceOf(Includes);
+    expect(result["count"]).toBeInstanceOf(GreaterThan);
+    expect(result["deletedAt"]).toBeInstanceOf(IsNull);
+    expect(result["isEnabled"]).toBe(true);
+  });
+});

package/Tests/Types/Telemetry/EntityTypeGroups.test.ts

@@ -0,0 +1,140 @@
+import EntityType from "../../../Types/Telemetry/EntityType";
+import EntitySource from "../../../Types/Telemetry/EntitySource";
+import {
+  INVENTORY_ENTITY_TYPES,
+  isNonTelemetryEntityType,
+  MANUAL_ENTITY_TYPES,
+} from "../../../Types/Telemetry/EntityTypeGroups";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * These sets decide which entity types the stale-entity prune may reach and
+ * which a user may create by hand. Both questions are answered by set
+ * membership, so a type that drifts out of (or silently into) a set changes
+ * behaviour with no other code change — which is exactly what these pin.
+ */
+
+describe("MANUAL_ENTITY_TYPES", () => {
+  test("is non-empty", () => {
+    expect(MANUAL_ENTITY_TYPES.size).toBeGreaterThan(0);
+  });
+
+  test("contains only real EntityType values", () => {
+    const known: Set<string> = new Set<string>(Object.values(EntityType));
+    for (const entityType of MANUAL_ENTITY_TYPES) {
+      expect(known.has(entityType)).toBe(true);
+    }
+  });
+
+  test("holds exactly the types with no discovery path", () => {
+    expect(Array.from(MANUAL_ENTITY_TYPES).sort()).toEqual(
+      [
+        EntityType.Appliance,
+        EntityType.ExternalDatabase,
+        EntityType.ExternalService,
+      ].sort(),
+    );
+  });
+
+  test("excludes observable types", () => {
+    /*
+     * A hand-made row of an observable type would key off the manual
+     * identity attribute and so could never converge with the row ingest
+     * derives for the same thing. See MANUAL_ENTITY_TYPES.
+     */
+    expect(MANUAL_ENTITY_TYPES.has(EntityType.Service)).toBe(false);
+    expect(MANUAL_ENTITY_TYPES.has(EntityType.Host)).toBe(false);
+    expect(MANUAL_ENTITY_TYPES.has(EntityType.KubernetesPod)).toBe(false);
+    expect(MANUAL_ENTITY_TYPES.has(EntityType.NetworkDevice)).toBe(false);
+  });
+});
+
+describe("INVENTORY_ENTITY_TYPES", () => {
+  test("contains only real EntityType values", () => {
+    const known: Set<string> = new Set<string>(Object.values(EntityType));
+    for (const entityType of INVENTORY_ENTITY_TYPES) {
+      expect(known.has(entityType)).toBe(true);
+    }
+  });
+
+  test("covers every inventory table the registry mirrors", () => {
+    expect(Array.from(INVENTORY_ENTITY_TYPES).sort()).toEqual(
+      [
+        EntityType.CloudResource,
+        EntityType.DockerHost,
+        EntityType.IoTDevice,
+        EntityType.NetworkDevice,
+        EntityType.PodmanHost,
+        EntityType.RumApplication,
+        EntityType.ServerlessFunction,
+      ].sort(),
+    );
+  });
+
+  test("excludes OTLP-derived types", () => {
+    expect(INVENTORY_ENTITY_TYPES.has(EntityType.Service)).toBe(false);
+    expect(INVENTORY_ENTITY_TYPES.has(EntityType.KubernetesCluster)).toBe(
+      false,
+    );
+    expect(INVENTORY_ENTITY_TYPES.has(EntityType.ProxmoxGuest)).toBe(false);
+  });
+});
+
+describe("the two groups are disjoint", () => {
+  test("no type is both manually creatable and inventory-mirrored", () => {
+    for (const entityType of MANUAL_ENTITY_TYPES) {
+      expect(INVENTORY_ENTITY_TYPES.has(entityType)).toBe(false);
+    }
+    for (const entityType of INVENTORY_ENTITY_TYPES) {
+      expect(MANUAL_ENTITY_TYPES.has(entityType)).toBe(false);
+    }
+  });
+});
+
+describe("isNonTelemetryEntityType", () => {
+  test("is true for every manual and inventory type", () => {
+    for (const entityType of MANUAL_ENTITY_TYPES) {
+      expect(isNonTelemetryEntityType(entityType)).toBe(true);
+    }
+    for (const entityType of INVENTORY_ENTITY_TYPES) {
+      expect(isNonTelemetryEntityType(entityType)).toBe(true);
+    }
+  });
+
+  test("is false for OTLP-derived types, which do have a heartbeat", () => {
+    const telemetryTypes: Array<EntityType> = Object.values(EntityType).filter(
+      (entityType: EntityType) => {
+        return (
+          !MANUAL_ENTITY_TYPES.has(entityType) &&
+          !INVENTORY_ENTITY_TYPES.has(entityType)
+        );
+      },
+    );
+
+    expect(telemetryTypes.length).toBeGreaterThan(0);
+
+    for (const entityType of telemetryTypes) {
+      expect(isNonTelemetryEntityType(entityType)).toBe(false);
+    }
+  });
+
+  test("every EntityType is classified one way or the other", () => {
+    for (const entityType of Object.values(EntityType)) {
+      expect(typeof isNonTelemetryEntityType(entityType)).toBe("boolean");
+    }
+  });
+});
+
+describe("EntitySource", () => {
+  test("has exactly the three lifecycles the registry distinguishes", () => {
+    expect(Object.values(EntitySource).sort()).toEqual(
+      ["discovered", "inventory", "manual"].sort(),
+    );
+  });
+
+  test("values are stable strings — they are persisted and queried on", () => {
+    expect(EntitySource.Discovered).toBe("discovered");
+    expect(EntitySource.Inventory).toBe("inventory");
+    expect(EntitySource.Manual).toBe("manual");
+  });
+});

package/Tests/Types/Workflow/StepTrace.test.ts

@@ -0,0 +1,235 @@
+import {
+  MAX_TRACE_STEPS,
+  MAX_TRACE_VALUE_LENGTH,
+  TRUNCATED_VALUE_SUFFIX,
+  WorkflowStepStatus,
+  WorkflowStepTrace,
+  WorkflowStepTraceEntry,
+  appendTraceStep,
+  emptyTrace,
+  parseTrace,
+  truncateTraceValue,
+  truncateTraceValues,
+} from "../../../Types/Workflow/StepTrace";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+type MakeEntryFunction = (
+  overrides?: Partial<WorkflowStepTraceEntry> | undefined,
+) => WorkflowStepTraceEntry;
+
+const makeEntry: MakeEntryFunction = (
+  overrides?: Partial<WorkflowStepTraceEntry> | undefined,
+): WorkflowStepTraceEntry => {
+  return {
+    componentId: "api-get-1",
+    metadataId: "api-get",
+    title: "API Get",
+    status: WorkflowStepStatus.Success,
+    startedAt: "2026-01-01T00:00:00.000Z",
+    completedAt: "2026-01-01T00:00:01.000Z",
+    durationInMs: 1000,
+    argumentValues: {},
+    returnValues: {},
+    executedPort: "success",
+    ...overrides,
+  };
+};
+
+describe("truncateTraceValue", () => {
+  test("leaves a short string alone", () => {
+    expect(truncateTraceValue("hello")).toBe("hello");
+  });
+
+  test("leaves a string exactly at the limit alone", () => {
+    const atLimit: string = "a".repeat(MAX_TRACE_VALUE_LENGTH);
+
+    expect(truncateTraceValue(atLimit)).toBe(atLimit);
+  });
+
+  test("cuts a string past the limit and says so", () => {
+    const tooLong: string = "a".repeat(MAX_TRACE_VALUE_LENGTH + 100);
+    const result: string = truncateTraceValue(tooLong) as string;
+
+    expect(result.endsWith(TRUNCATED_VALUE_SUFFIX)).toBe(true);
+    expect(result.length).toBe(
+      MAX_TRACE_VALUE_LENGTH + TRUNCATED_VALUE_SUFFIX.length,
+    );
+  });
+
+  test("leaves small structured values as structure, not text", () => {
+    const value: JSONObject = { a: 1, b: "two" };
+
+    expect(truncateTraceValue(value)).toEqual(value);
+  });
+
+  /*
+   * Half a serialized object looks like data but cannot be parsed, so a large
+   * object is replaced wholesale rather than cut in the middle.
+   */
+  test("replaces a large object with cut text rather than half an object", () => {
+    const big: JSONObject = { body: "x".repeat(MAX_TRACE_VALUE_LENGTH + 500) };
+    const result: unknown = truncateTraceValue(big);
+
+    expect(typeof result).toBe("string");
+    expect((result as string).endsWith(TRUNCATED_VALUE_SUFFIX)).toBe(true);
+  });
+
+  test("leaves primitives of other types alone", () => {
+    expect(truncateTraceValue(42)).toBe(42);
+    expect(truncateTraceValue(true)).toBe(true);
+    expect(truncateTraceValue(null)).toBeNull();
+  });
+
+  test("says so rather than throwing on a circular value", () => {
+    const circular: JSONObject = {};
+    (circular as unknown as { self: unknown }).self = circular;
+
+    expect(truncateTraceValue(circular)).toBe("[value could not be recorded]");
+  });
+
+  test("keeps a large array as text rather than dropping it", () => {
+    const bigArray: Array<string> = new Array(2000).fill("abcdefghij");
+    const result: unknown = truncateTraceValue(
+      bigArray as unknown as JSONObject,
+    );
+
+    expect(typeof result).toBe("string");
+  });
+});
+
+describe("truncateTraceValues", () => {
+  test("truncates each value independently", () => {
+    const values: JSONObject = {
+      small: "ok",
+      big: "x".repeat(MAX_TRACE_VALUE_LENGTH + 10),
+    };
+
+    const result: JSONObject = truncateTraceValues(values);
+
+    expect(result["small"]).toBe("ok");
+    expect((result["big"] as string).endsWith(TRUNCATED_VALUE_SUFFIX)).toBe(
+      true,
+    );
+  });
+
+  test("copes with an empty object", () => {
+    expect(truncateTraceValues({})).toEqual({});
+  });
+
+  test("keeps a redaction marker exactly as it is", () => {
+    expect(truncateTraceValues({ token: "[REDACTED]" })["token"]).toBe(
+      "[REDACTED]",
+    );
+  });
+});
+
+describe("appendTraceStep", () => {
+  test("adds a step to an empty trace", () => {
+    const trace: WorkflowStepTrace = appendTraceStep(emptyTrace(), makeEntry());
+
+    expect(trace.steps).toHaveLength(1);
+    expect(trace.truncated).toBeFalsy();
+  });
+
+  test("keeps steps in the order they ran", () => {
+    let trace: WorkflowStepTrace = emptyTrace();
+
+    trace = appendTraceStep(trace, makeEntry({ componentId: "first" }));
+    trace = appendTraceStep(trace, makeEntry({ componentId: "second" }));
+
+    expect(
+      trace.steps.map((step: WorkflowStepTraceEntry) => {
+        return step.componentId;
+      }),
+    ).toEqual(["first", "second"]);
+  });
+
+  test("does not mutate the trace it was given", () => {
+    const original: WorkflowStepTrace = emptyTrace();
+
+    appendTraceStep(original, makeEntry());
+
+    expect(original.steps).toHaveLength(0);
+  });
+
+  test("holds exactly the cap without flagging truncation", () => {
+    let trace: WorkflowStepTrace = emptyTrace();
+
+    for (let i: number = 0; i < MAX_TRACE_STEPS; i++) {
+      trace = appendTraceStep(trace, makeEntry({ componentId: `step-${i}` }));
+    }
+
+    expect(trace.steps).toHaveLength(MAX_TRACE_STEPS);
+    expect(trace.truncated).toBeFalsy();
+  });
+
+  /*
+   * A failed run is read from the end — the step that broke it is the last
+   * one — so the cap drops the oldest steps, not the newest.
+   */
+  test("drops the oldest steps past the cap and keeps the newest", () => {
+    let trace: WorkflowStepTrace = emptyTrace();
+
+    for (let i: number = 0; i < MAX_TRACE_STEPS + 5; i++) {
+      trace = appendTraceStep(trace, makeEntry({ componentId: `step-${i}` }));
+    }
+
+    expect(trace.steps).toHaveLength(MAX_TRACE_STEPS);
+    expect(trace.truncated).toBe(true);
+    expect(trace.steps[trace.steps.length - 1]?.componentId).toBe(
+      `step-${MAX_TRACE_STEPS + 4}`,
+    );
+    expect(trace.steps[0]?.componentId).toBe("step-5");
+  });
+
+  test("stays flagged as truncated once it has been", () => {
+    let trace: WorkflowStepTrace = emptyTrace();
+
+    for (let i: number = 0; i < MAX_TRACE_STEPS + 2; i++) {
+      trace = appendTraceStep(trace, makeEntry());
+    }
+
+    trace = appendTraceStep(trace, makeEntry());
+
+    expect(trace.truncated).toBe(true);
+  });
+});
+
+describe("parseTrace", () => {
+  test("reads back what was written", () => {
+    const trace: WorkflowStepTrace = appendTraceStep(
+      emptyTrace(),
+      makeEntry({ componentId: "log-1" }),
+    );
+
+    const roundTripped: WorkflowStepTrace = parseTrace(
+      JSON.parse(JSON.stringify(trace)),
+    );
+
+    expect(roundTripped.steps).toHaveLength(1);
+    expect(roundTripped.steps[0]?.componentId).toBe("log-1");
+  });
+
+  test("carries the truncated flag back", () => {
+    expect(parseTrace({ steps: [], truncated: true }).truncated).toBe(true);
+  });
+
+  /*
+   * Rows written before the column existed, or by an older build, must read as
+   * an empty trace so the viewer falls back to the raw log instead of throwing.
+   */
+  test("treats anything that is not a trace as empty", () => {
+    expect(parseTrace(null).steps).toEqual([]);
+    expect(parseTrace(undefined as never).steps).toEqual([]);
+    expect(parseTrace("nonsense").steps).toEqual([]);
+    expect(parseTrace(42).steps).toEqual([]);
+    expect(parseTrace([]).steps).toEqual([]);
+    expect(parseTrace({}).steps).toEqual([]);
+    expect(parseTrace({ steps: "not an array" }).steps).toEqual([]);
+  });
+
+  test("an empty trace is not flagged truncated", () => {
+    expect(parseTrace(null).truncated).toBeFalsy();
+  });
+});