@oneuptime/common 12.0.2 → 12.0.4

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/ColumnLength.test.ts

@@ -42,7 +42,13 @@ describe("enum ColumnLength", () => {
   });
 
   test("ColumnLength.HashedString", () => {
-    expect(ColumnLength.HashedString).toEqual(64);
+    /*
+     * Not 64 (a bare SHA-256 digest) since user passwords became scrypt
+     * hashes that carry their own cost parameters: `scrypt$N=...,r=...,p=...$
+     * <64 hex>`, around 90 characters. Narrowing this back would truncate
+     * every password on write and lock the whole instance out.
+     */
+    expect(ColumnLength.HashedString).toEqual(255);
   });
 
   test("ColumnLength.Phone", () => {

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();
+    });
+  });
 });