@oneuptime/common 12.0.2 → 12.0.3

package/Tests/Types/Database/BigIntColumnTransformer.test.ts

@@ -0,0 +1,147 @@
+import { getBigIntDatabaseTransformer } from "../../../Types/Database/BigIntColumnTransformer";
+import { ValueTransformer } from "typeorm/decorator/options/ValueTransformer";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test — the Postgres bigint round-trip used by counter
+ * columns.
+ *
+ * The interesting half is `to(undefined)`. TypeORM applies a column
+ * transformer BEFORE it decides whether the column was supplied at all:
+ *
+ *   InsertQueryBuilder.createColumnValueExpression
+ *     -> driver.preparePersistentValue   (runs transformer.to)
+ *     -> if (value === undefined) expression += "DEFAULT"
+ *
+ * so a transformer that answers `null` for `undefined` has already turned
+ * "the caller did not set this column" into "the caller set it to NULL" by
+ * the time that check runs, and the column DEFAULT is unreachable. On the
+ * drop-filter `droppedCount` columns — NOT NULL DEFAULT 0, written only by
+ * the ingest path — that made every single insert fail:
+ *
+ *   null value in column "droppedCount" of relation "LogDropFilter"
+ *   violates not-null constraint
+ *
+ * i.e. creating any log drop filter in the dashboard returned HTTP 500.
+ * github.com/OneUptime/oneuptime/issues/3026
+ */
+
+const transformer: ValueTransformer = getBigIntDatabaseTransformer();
+
+describe("getBigIntDatabaseTransformer().to", () => {
+  /*
+   * The regression. `undefined` and `null` are NOT interchangeable here:
+   * one means "use the column default", the other means "write NULL".
+   */
+  it("passes undefined through so the column DEFAULT applies", () => {
+    expect(transformer.to(undefined)).toBeUndefined();
+  });
+
+  it("does not confuse undefined with null", () => {
+    expect(transformer.to(undefined)).not.toBeNull();
+  });
+
+  it("keeps an explicit null as null", () => {
+    expect(transformer.to(null)).toBeNull();
+  });
+
+  it("stringifies a number, because the pg driver binds bigint as text", () => {
+    expect(transformer.to(0)).toBe("0");
+    expect(transformer.to(1)).toBe("1");
+    expect(transformer.to(42)).toBe("42");
+  });
+
+  it("truncates rather than emitting a decimal Postgres would reject", () => {
+    expect(transformer.to(10.9)).toBe("10");
+    expect(transformer.to(-10.9)).toBe("-10");
+  });
+
+  /*
+   * The reason these columns are bigint at all: a sample filter on a
+   * high-volume project passes 2^31 well within a year, and a silently
+   * wrapped diagnostic counter is worse than no counter.
+   */
+  it("carries a value past the 32-bit range without losing precision", () => {
+    expect(transformer.to(4_294_967_296)).toBe("4294967296");
+    expect(transformer.to(Number.MAX_SAFE_INTEGER)).toBe("9007199254740991");
+  });
+
+  /*
+   * `Math.trunc(NaN).toString()` is the string "NaN", which Postgres
+   * rejects with a syntax error naming neither the column nor the caller.
+   */
+  it("refuses to emit a non-finite value as text", () => {
+    expect(transformer.to(NaN)).toBeNull();
+    expect(transformer.to(Infinity)).toBeNull();
+    expect(transformer.to(-Infinity)).toBeNull();
+  });
+});
+
+describe("getBigIntDatabaseTransformer().from", () => {
+  /*
+   * node-postgres hands bigint back as a string — it does not fit a JS
+   * number in the general case. Every value stored in these counters is
+   * inside MAX_SAFE_INTEGER, and the dashboard renders them as numbers.
+   */
+  it("parses the string the driver returns into a number", () => {
+    expect(transformer.from("0")).toBe(0);
+    expect(transformer.from("42")).toBe(42);
+    expect(transformer.from("9007199254740991")).toBe(9007199254740991);
+  });
+
+  it("accepts a number unchanged, in case a driver already parsed it", () => {
+    expect(transformer.from(7)).toBe(7);
+  });
+
+  it("maps a null column to null rather than 0", () => {
+    expect(transformer.from(null)).toBeNull();
+    expect(transformer.from(undefined)).toBeNull();
+  });
+
+  it("maps unparsable text to null rather than NaN", () => {
+    expect(transformer.from("not a number")).toBeNull();
+    expect(transformer.from("")).toBeNull();
+  });
+
+  it("round-trips a counter value", () => {
+    for (const value of [0, 1, 999, 4_294_967_296]) {
+      expect(transformer.from(transformer.to(value))).toBe(value);
+    }
+  });
+});
+
+/*
+ * A miniature of TypeORM's own decision, so the consequence of the
+ * transformer's answer is asserted rather than left to a comment. Mirrors
+ * PostgresDriver.preparePersistentValue followed by
+ * InsertQueryBuilder.createColumnValueExpression.
+ */
+describe("the INSERT expression TypeORM derives from this transformer", () => {
+  type InsertExpression = "DEFAULT" | "NULL" | string;
+
+  function insertExpressionFor(value: number | null | undefined): string {
+    const prepared: unknown = transformer.to(value);
+
+    if (prepared === undefined) {
+      return "DEFAULT";
+    }
+
+    if (prepared === null) {
+      return "NULL";
+    }
+
+    return String(prepared);
+  }
+
+  it("emits DEFAULT for a counter the caller never set", () => {
+    const expression: InsertExpression = insertExpressionFor(undefined);
+
+    expect(expression).toBe("DEFAULT");
+    // The old inline transformer produced this, and NOT NULL rejected it.
+    expect(expression).not.toBe("NULL");
+  });
+
+  it("emits the value for a counter the caller did set", () => {
+    expect(insertExpressionFor(5)).toBe("5");
+  });
+});

package/Tests/Types/Database/DatabasePropertyTransformer.test.ts

@@ -0,0 +1,140 @@
+import Recurring from "../../../Types/Events/Recurring";
+import RestrictionTimes from "../../../Types/OnCallDutyPolicy/RestrictionTimes";
+import ObjectID from "../../../Types/ObjectID";
+import Email from "../../../Types/Email";
+import Color from "../../../Types/Color";
+import EventInterval from "../../../Types/Events/EventInterval";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import { ValueTransformer } from "typeorm/decorator/options/ValueTransformer";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test — `DatabaseProperty.getDatabaseTransformer()`, the one
+ * transformer behind nearly every non-primitive column in the schema.
+ *
+ * Its `to` has to keep `undefined` and `null` apart. TypeORM applies the
+ * transformer BEFORE deciding whether the caller supplied the column:
+ *
+ *   InsertQueryBuilder.createColumnValueExpression
+ *     -> driver.preparePersistentValue   (runs transformer.to)
+ *     -> if (value === undefined) expression += "DEFAULT"
+ *
+ * Every `toDatabase` implementation returns null for a falsy input, so
+ * before this guard an omitted column arrived as an explicit NULL and the
+ * column's DEFAULT was unreachable. On a NOT NULL column with a default that
+ * is a not-null constraint violation — an HTTP 500 — on every create that
+ * does not mention the column. That is the mechanism behind
+ * github.com/OneUptime/oneuptime/issues/3026 (the drop-filter counters), and
+ * `OnCallDutyPolicyScheduleLayer.rotation` / `.restrictionTimes` are the same
+ * shape: NOT NULL, with a JSON default, written through this transformer.
+ *
+ * UPDATE is unaffected in both directions — UpdateQueryBuilder drops
+ * undefined properties before the transformer runs — so this only ever
+ * changes an INSERT from "write NULL" to "use the DEFAULT".
+ */
+
+interface TransformerCase {
+  name: string;
+  transformer: ValueTransformer;
+  sample: unknown;
+}
+
+const CASES: Array<TransformerCase> = [
+  {
+    name: "Recurring",
+    transformer: Recurring.getDatabaseTransformer(),
+    sample: Recurring.getDefault(),
+  },
+  {
+    name: "RestrictionTimes",
+    transformer: RestrictionTimes.getDatabaseTransformer(),
+    sample: RestrictionTimes.getDefault(),
+  },
+  {
+    name: "ObjectID",
+    transformer: ObjectID.getDatabaseTransformer(),
+    sample: new ObjectID("11111111-1111-4111-8111-111111111111"),
+  },
+  {
+    name: "Email",
+    transformer: Email.getDatabaseTransformer(),
+    sample: new Email("someone@oneuptime.com"),
+  },
+  {
+    name: "Color",
+    transformer: Color.getDatabaseTransformer(),
+    sample: new Color("#ff0000"),
+  },
+];
+
+describe.each(CASES)(
+  "$name.getDatabaseTransformer()",
+  ({ transformer, sample }: TransformerCase) => {
+    it("passes undefined through so the column DEFAULT applies", () => {
+      expect(transformer.to(undefined)).toBeUndefined();
+    });
+
+    it("does not collapse undefined into null", () => {
+      expect(transformer.to(undefined)).not.toBeNull();
+    });
+
+    /*
+     * An explicit null is a different instruction — "store nothing here" —
+     * and still has to reach the column as NULL.
+     */
+    it("keeps an explicit null as null", () => {
+      expect(transformer.to(null)).toBeNull();
+    });
+
+    it("still serializes a real value", () => {
+      expect(transformer.to(sample)).not.toBeUndefined();
+      expect(transformer.to(sample)).not.toBeNull();
+    });
+  },
+);
+
+describe("the INSERT expression TypeORM derives for a NOT NULL column", () => {
+  /*
+   * A miniature of PostgresDriver.preparePersistentValue followed by
+   * InsertQueryBuilder.createColumnValueExpression, so the consequence is
+   * asserted rather than described.
+   */
+  function insertExpressionFor(
+    transformer: ValueTransformer,
+    value: unknown,
+  ): string {
+    const prepared: unknown = transformer.to(value);
+
+    if (prepared === undefined) {
+      return "DEFAULT";
+    }
+
+    if (prepared === null) {
+      return "NULL";
+    }
+
+    return "?";
+  }
+
+  it("uses the schedule layer's rotation default instead of NULL", () => {
+    expect(
+      insertExpressionFor(Recurring.getDatabaseTransformer(), undefined),
+    ).toBe("DEFAULT");
+  });
+
+  it("uses the schedule layer's restriction default instead of NULL", () => {
+    expect(
+      insertExpressionFor(RestrictionTimes.getDatabaseTransformer(), undefined),
+    ).toBe("DEFAULT");
+  });
+
+  it("still binds a supplied value", () => {
+    const rotation: Recurring = new Recurring();
+    rotation.intervalType = EventInterval.Week;
+    rotation.intervalCount = new PositiveNumber(2);
+
+    expect(
+      insertExpressionFor(Recurring.getDatabaseTransformer(), rotation),
+    ).toBe("?");
+  });
+});

package/Tests/Types/Database/NumericColumnValue.test.ts

@@ -0,0 +1,127 @@
+import {
+  coerceNumericColumnValue,
+  isNumericTableColumnType,
+} from "../../../Types/Database/NumericColumnValue";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test — normalizing a JSON value bound for a number column.
+ *
+ * HTML has no numeric input event: `<input type="number">` hands back
+ * `e.target.value`, a string. So the dashboard posted the JSON string "10"
+ * for every number field, and Postgres quietly coerced '10' to 10 on the way
+ * in — which is why nobody noticed until a server-side check read the value
+ * BEFORE it was stored:
+ *
+ *   BadDataException: Sample percentage is required when the action is
+ *   "Sample". Enter the percentage of matching logs to keep, between 1 and 99.
+ *
+ * on a form where the user had typed a percentage. HTTP 400 on a valid
+ * submission. github.com/OneUptime/oneuptime/issues/3027
+ */
+
+describe("isNumericTableColumnType", () => {
+  it("covers every column type stored as a plain JS number", () => {
+    for (const type of [
+      TableColumnType.Number,
+      TableColumnType.SmallNumber,
+      TableColumnType.BigNumber,
+      TableColumnType.PositiveNumber,
+      TableColumnType.SmallPositiveNumber,
+      TableColumnType.BigPositiveNumber,
+    ]) {
+      expect(isNumericTableColumnType(type)).toBe(true);
+    }
+  });
+
+  /*
+   * The types that would be destroyed by coercion. `Port` and `Version` are
+   * wrapped objects and `Date` is a Date, however numeric they look.
+   */
+  it("excludes types that only look numeric", () => {
+    for (const type of [
+      TableColumnType.Port,
+      TableColumnType.Version,
+      TableColumnType.Date,
+      TableColumnType.ShortText,
+      TableColumnType.LongText,
+      TableColumnType.Boolean,
+      TableColumnType.ObjectID,
+      TableColumnType.Entity,
+      TableColumnType.EntityArray,
+      TableColumnType.JSON,
+    ]) {
+      expect(isNumericTableColumnType(type)).toBe(false);
+    }
+  });
+
+  it("treats a missing type as not numeric", () => {
+    expect(isNumericTableColumnType(undefined)).toBe(false);
+    expect(isNumericTableColumnType(null)).toBe(false);
+  });
+});
+
+describe("coerceNumericColumnValue", () => {
+  it("converts the string an <input type=number> produces", () => {
+    expect(coerceNumericColumnValue("10")).toBe(10);
+    expect(coerceNumericColumnValue("1")).toBe(1);
+    expect(coerceNumericColumnValue("99")).toBe(99);
+  });
+
+  it("handles the shapes a browser can put in that string", () => {
+    expect(coerceNumericColumnValue("0")).toBe(0);
+    expect(coerceNumericColumnValue("-5")).toBe(-5);
+    expect(coerceNumericColumnValue("2.5")).toBe(2.5);
+    expect(coerceNumericColumnValue(" 42 ")).toBe(42);
+    expect(coerceNumericColumnValue("1e3")).toBe(1000);
+  });
+
+  it("leaves a value that is already a number alone", () => {
+    expect(coerceNumericColumnValue(10)).toBe(10);
+    expect(coerceNumericColumnValue(0)).toBe(0);
+  });
+
+  it("leaves null and undefined alone", () => {
+    expect(coerceNumericColumnValue(null)).toBeNull();
+    expect(coerceNumericColumnValue(undefined)).toBeUndefined();
+  });
+
+  /*
+   * `Number("")` is 0. Writing a real 0 for a field the user cleared would
+   * be a silent data change, and for a sample percentage specifically, 0 is
+   * the value that used to mean "throw away half". Leave it untouched and
+   * let the field's own validation speak.
+   */
+  it("does not turn a cleared field into zero", () => {
+    expect(coerceNumericColumnValue("")).toBe("");
+    expect(coerceNumericColumnValue("   ")).toBe("   ");
+  });
+
+  it("leaves unparsable text alone so validation can reject it by name", () => {
+    for (const garbage of ["abc", "10abc", "NaN", "Infinity", "--1", "1,000"]) {
+      expect(coerceNumericColumnValue(garbage)).toBe(garbage);
+    }
+  });
+
+  it("never invents a non-finite number", () => {
+    const results: Array<unknown> = ["Infinity", "-Infinity", "NaN"].map(
+      (value: string) => {
+        return coerceNumericColumnValue(value);
+      },
+    );
+
+    for (const result of results) {
+      expect(typeof result).toBe("string");
+    }
+  });
+
+  it("passes non-string, non-number values through untouched", () => {
+    const object: Record<string, string> = { a: "1" };
+    const array: Array<number> = [1];
+
+    expect(coerceNumericColumnValue(object)).toBe(object);
+    expect(coerceNumericColumnValue(array)).toBe(array);
+    expect(coerceNumericColumnValue(true)).toBe(true);
+  });
+});

package/Tests/Types/Decimal.test.ts

@@ -89,4 +89,41 @@ describe("Decimal", () => {
       expect(restored.equals(original)).toBe(true);
     });
   });
+
+  /*
+   * A decimal column is declared `TableColumnType.Number`, so whatever
+   * reaches the transformer may be a Decimal, a string, or a plain number
+   * depending on how far the request body got through deserialization.
+   */
+  describe("getDatabaseTransformer().to", () => {
+    const transformer: ReturnType<typeof Decimal.getDatabaseTransformer> =
+      Decimal.getDatabaseTransformer();
+
+    test("stores a Decimal instance as its string form", () => {
+      expect(transformer.to(new Decimal(125.5))).toBe("125.5");
+    });
+
+    test("stores a raw string", () => {
+      expect(transformer.to("125.5")).toBe("125.5");
+    });
+
+    test("stores a raw number", () => {
+      expect(transformer.to(125.5)).toBe("125.5");
+    });
+
+    /*
+     * `0` is a perfectly good decimal, and both of its columns are NOT NULL.
+     * A truthiness check used to send it to null, which the column rejects.
+     */
+    test("stores zero rather than turning it into null", () => {
+      expect(transformer.to(0)).toBe("0");
+      expect(transformer.to("0")).toBe("0");
+      expect(transformer.to(new Decimal(0))).toBe("0");
+    });
+
+    test("keeps undefined distinct from null so a column DEFAULT applies", () => {
+      expect(transformer.to(undefined)).toBeUndefined();
+      expect(transformer.to(null)).toBeNull();
+    });
+  });
 });

package/Tests/Types/Monitor/SnmpVersionParsing.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, test } from "@jest/globals";
+import SnmpVersion, {
+  SnmpVersionUtil,
+} from "../../../Types/Monitor/SnmpMonitor/SnmpVersion";
+
+/*
+ * snmpVersion is a free-text column with two live spellings: the enum VALUES
+ * ("1"/"2c"/"3") that the probe contract uses, and the enum KEYS ("V1"/"V2c"/
+ * "V3") that every form writes and the column default holds. SnmpVersionUtil is
+ * the seam that reconciles them. Reading the column any other way silently takes
+ * the wrong branch — a stored "V3" is not === SnmpVersion.V3 ("3"), so a v3
+ * device would read as v2c and be polled in cleartext.
+ *
+ * Unlike the SnmpV3 protocol parsers, parse() cannot return undefined: the probe
+ * must pick exactly one session type, so an unreadable value falls back to v2c
+ * rather than refusing. These tests pin both the recognized spellings and that
+ * deliberate default so a future edit cannot widen or narrow it unnoticed.
+ */
+
+describe("SnmpVersionUtil.parse", () => {
+  test.each([
+    ["1", SnmpVersion.V1],
+    ["2c", SnmpVersion.V2c],
+    ["3", SnmpVersion.V3],
+  ])(
+    "reads the probe-contract value spelling %j",
+    (stored: string, expected: SnmpVersion) => {
+      expect(SnmpVersionUtil.parse(stored)).toBe(expected);
+    },
+  );
+
+  /*
+   * The stored spelling — what forms write and the column default holds. This
+   * is the spelling the bare-cast bug got wrong, so it is the one that most
+   * needs a test.
+   */
+  test.each([
+    ["V1", SnmpVersion.V1],
+    ["V2c", SnmpVersion.V2c],
+    ["V3", SnmpVersion.V3],
+  ])(
+    "reads the stored enum-key spelling %j",
+    (stored: string, expected: SnmpVersion) => {
+      expect(SnmpVersionUtil.parse(stored)).toBe(expected);
+    },
+  );
+
+  test.each([
+    ["V1", SnmpVersion.V1],
+    ["v1", SnmpVersion.V1],
+    ["  1  ", SnmpVersion.V1],
+    ["\tv3\n", SnmpVersion.V3],
+    ["V3", SnmpVersion.V3],
+    ["v3", SnmpVersion.V3],
+  ])(
+    "tolerates case and surrounding whitespace in %j",
+    (stored: string, expected: SnmpVersion) => {
+      expect(SnmpVersionUtil.parse(stored)).toBe(expected);
+    },
+  );
+
+  /*
+   * v2c is the fallback branch, so every v2c spelling AND every value the parser
+   * does not recognize must land here. The two are indistinguishable by design:
+   * there is no "undefined version", the probe always needs a session type, and
+   * v2c is the safe historic default. Anything that stops mapping to v2c here is
+   * a behavior change, not a bug fix.
+   */
+  test.each([
+    ["2c", "an exact value"],
+    ["V2c", "the stored key"],
+    ["v2c", "lowercased key"],
+    ["2", "the version number without the c"],
+    ["V2", "the key without the c"],
+    [undefined, "an undefined column"],
+    [null, "a null column"],
+    ["", "an empty string"],
+    ["   ", "whitespace only"],
+    ["nonsense", "garbage"],
+    ["v4", "a version that does not exist"],
+    ["0", "a zero"],
+  ])(
+    "falls back to v2c for %j (%s)",
+    (stored: string | undefined | null, _description: string) => {
+      expect(SnmpVersionUtil.parse(stored)).toBe(SnmpVersion.V2c);
+    },
+  );
+});
+
+describe("SnmpVersionUtil.isV3", () => {
+  test.each([["3"], ["v3"], ["V3"], ["  V3  "], ["\tv3\n"]])(
+    "is true for the v3 spelling %j",
+    (stored: string) => {
+      expect(SnmpVersionUtil.isV3(stored)).toBe(true);
+    },
+  );
+
+  /*
+   * The consequential direction: everything that is not v3 must read as not-v3,
+   * because isV3 gates whether auth/priv credentials are applied. A false
+   * positive would be harmless; a false negative strands a v3 device in a v2c
+   * branch and polls it without credentials.
+   */
+  test.each([
+    ["1"],
+    ["V1"],
+    ["2c"],
+    ["V2c"],
+    ["v2c"],
+    ["2"],
+    [undefined],
+    [null],
+    [""],
+    ["   "],
+    ["nonsense"],
+  ])(
+    "is false for the non-v3 value %j",
+    (stored: string | undefined | null) => {
+      expect(SnmpVersionUtil.isV3(stored)).toBe(false);
+    },
+  );
+
+  test("agrees with parse() for every recognized spelling", () => {
+    for (const spelling of ["1", "v1", "V1", "2c", "V2c", "3", "v3", "V3"]) {
+      expect(SnmpVersionUtil.isV3(spelling)).toBe(
+        SnmpVersionUtil.parse(spelling) === SnmpVersion.V3,
+      );
+    }
+  });
+});
+
+describe("every enum member survives a round trip", () => {
+  /*
+   * Exhaustive over the enum rather than a fixed list, so adding a version
+   * without teaching parse() its value AND key spelling fails here instead of
+   * silently collapsing to v2c in production.
+   */
+  test("each value spelling parses back to itself", () => {
+    for (const member of Object.values(SnmpVersion)) {
+      expect(SnmpVersionUtil.parse(member)).toBe(member);
+    }
+  });
+
+  test("each key spelling parses to its member", () => {
+    for (const key of Object.keys(SnmpVersion)) {
+      // Keys are "V1"/"V2c"/"V3"; the member is looked up by that key.
+      const expected: SnmpVersion =
+        SnmpVersion[key as keyof typeof SnmpVersion];
+      expect(SnmpVersionUtil.parse(key)).toBe(expected);
+    }
+  });
+});

package/Tests/Types/Port.test.ts

@@ -36,4 +36,42 @@ describe("Testing class port", () => {
     const value: Port = new Port("6000");
     expect(typeof value.port.positiveNumber).toBe("number");
   });
+
+  /*
+   * A port column is declared `TableColumnType.Number`, so whatever reaches
+   * the transformer may be a Port, a string, or a plain number depending on
+   * how far the request body got through deserialization. A raw number used
+   * to fall off the end of `toDatabase` and return null, which wrote NULL
+   * over an SMTP port the user had just typed — silently, since null is a
+   * legal value for the column.
+   */
+  describe("getDatabaseTransformer().to", () => {
+    const transformer: ReturnType<typeof Port.getDatabaseTransformer> =
+      Port.getDatabaseTransformer();
+
+    test("stores a Port instance as its number", () => {
+      expect(transformer.to(new Port(587))).toBe(587);
+    });
+
+    test("stores a raw string port as a number", () => {
+      expect(transformer.to("587")).toBe(587);
+    });
+
+    test("stores a raw number port rather than dropping it", () => {
+      expect(transformer.to(587)).toBe(587);
+      expect(transformer.to(0)).toBe(0);
+      expect(transformer.to(65535)).toBe(65535);
+    });
+
+    test("keeps undefined distinct from null so a column DEFAULT applies", () => {
+      expect(transformer.to(undefined)).toBeUndefined();
+      expect(transformer.to(null)).toBeNull();
+    });
+
+    test("rejects a port outside the valid range instead of storing null", () => {
+      expect(() => {
+        return transformer.to(70000);
+      }).toThrow(BadDataException);
+    });
+  });
 });