@oneuptime/common 12.0.5 → 12.0.6

package/Tests/Server/Utils/Database/PostgresErrorTranslator.test.ts

@@ -1,4 +1,6 @@
-import PostgresErrorTranslator from "../../../../Server/Utils/Database/PostgresErrorTranslator";
+import PostgresErrorTranslator, {
+  TranslatedPostgresException,
+} from "../../../../Server/Utils/Database/PostgresErrorTranslator";
 import BadDataException from "../../../../Types/Exception/BadDataException";
 import Exception from "../../../../Types/Exception/Exception";
 import { describe, expect, it } from "@jest/globals";
@@ -7,7 +9,9 @@ import { describe, expect, it } from "@jest/globals";
  * Contract under test: TypeORM's QueryFailedError is not an Exception, so it
  * used to fall through StartServer's generic handler and reach the client as a
  * bare 500 "Server Error" — which is exactly what deleting a project hit when
- * another project's MonitorStatusTimeline rows still referenced its statuses.
+ * another project's MonitorStatusTimeline rows still referenced its statuses,
+ * and what issue #3020 hit when a second ProjectCallSMSConfig was given Twilio
+ * credentials another row already held.
  *
  * The translator turns the actionable Postgres failures into a
  * BadDataException (400) and leaves everything else untouched.
@@ -33,6 +37,22 @@ const foreignKeyDeleteError: () => FakeQueryFailedError =
     };
   };
 
+/*
+ * The literal failure from issue #3020: PUT /api/call-sms-config setting a
+ * Twilio account SID that another ProjectCallSMSConfig row already carried.
+ */
+const twilioAccountSidCollision: () => FakeQueryFailedError =
+  (): FakeQueryFailedError => {
+    return {
+      message:
+        'duplicate key value violates unique constraint "UQ_0886139eac04ad49627e446d477"',
+      code: "23505",
+      table: "ProjectCallSMSConfig",
+      detail:
+        'Key ("twilioAccountSID")=(AC-redacted-sid-that-must-not-leak) already exists.',
+    };
+  };
+
 describe("PostgresErrorTranslator", () => {
   describe("foreign key violation on delete", () => {
     it("translates to a BadDataException naming the blocking table", () => {
@@ -86,17 +106,218 @@ describe("PostgresErrorTranslator", () => {
     });
   });
 
-  describe("errors it should not touch", () => {
-    it("passes through a non-foreign-key Postgres error unchanged", () => {
-      const uniqueViolation: FakeQueryFailedError = {
+  describe("unique violation (issue #3020)", () => {
+    it("translates to a BadDataException naming the table and the column", () => {
+      const translated: unknown = PostgresErrorTranslator.translate(
+        twilioAccountSidCollision(),
+      );
+
+      expect(translated).toBeInstanceOf(BadDataException);
+      expect((translated as Exception).message).toBe(
+        "A Project Call SMS Config with this Twilio Account SID already exists. Please use a different value and try again.",
+      );
+    });
+
+    it("is a 400, not the bare 500 the issue reported", () => {
+      /*
+       * The whole point: the reporter saw `{"error":"Server Error"}` with no
+       * indication of which field was at fault.
+       */
+      const translated: unknown = PostgresErrorTranslator.translate(
+        twilioAccountSidCollision(),
+      );
+
+      expect((translated as Exception).message).not.toBe("Server Error");
+      expect(translated).toBeInstanceOf(BadDataException);
+    });
+
+    it("does not leak the colliding value — it may belong to another project", () => {
+      const translated: unknown = PostgresErrorTranslator.translate(
+        twilioAccountSidCollision(),
+      );
+
+      expect((translated as Exception).message).not.toContain(
+        "AC-redacted-sid-that-must-not-leak",
+      );
+    });
+
+    it("handles an unquoted column name", () => {
+      const translated: unknown = PostgresErrorTranslator.translate({
         message: "duplicate key value violates unique constraint",
         code: "23505",
         table: "Project",
         detail: "Key (slug)=(acme) already exists.",
+      });
+
+      expect((translated as Exception).message).toBe(
+        "A Project with this Slug already exists. Please use a different value and try again.",
+      );
+    });
+
+    it("handles a composite key, listing every column", () => {
+      const translated: unknown = PostgresErrorTranslator.translate({
+        message: "duplicate key value violates unique constraint",
+        code: "23505",
+        table: "NetworkInterface",
+        detail:
+          'Key ("networkDeviceId", "interfaceIndex")=(cfc2f04f-79cb-4344-8c54-dafe5e3a290c, 3) already exists.',
+      });
+
+      expect((translated as Exception).message).toBe(
+        "A Network Interface with the same Network Device Id, Interface Index already exists. Please use different values and try again.",
+      );
+    });
+
+    it("does not mistake the value list for the column list", () => {
+      /*
+       * `Key (a)=(b) already exists` has two parenthesised groups. Reading the
+       * wrong one would put another row's data in the message.
+       */
+      const translated: unknown = PostgresErrorTranslator.translate({
+        message: "duplicate key value violates unique constraint",
+        code: "23505",
+        table: "Project",
+        detail: "Key (slug)=(secret-customer-name) already exists.",
+      });
+
+      expect((translated as Exception).message).not.toContain(
+        "secret-customer-name",
+      );
+    });
+
+    it("reads the pg fields off driverError when the wrapper has no code", () => {
+      const translated: unknown = PostgresErrorTranslator.translate({
+        message: "wrapped",
+        driverError: twilioAccountSidCollision(),
+      });
+
+      expect(translated).toBeInstanceOf(BadDataException);
+      expect((translated as Exception).message).toContain("Twilio Account SID");
+    });
+
+    it("falls back to a generic message when the table is unknown", () => {
+      const translated: unknown = PostgresErrorTranslator.translate({
+        message: "duplicate key value violates unique constraint",
+        code: "23505",
+        detail: 'Key ("twilioAccountSID")=(AC123) already exists.',
+      });
+
+      expect((translated as Exception).message).toBe(
+        "A record with this Twilio Account SID already exists. Please use a different value and try again.",
+      );
+    });
+
+    it("falls back to a generic message when the columns cannot be parsed", () => {
+      const translated: unknown = PostgresErrorTranslator.translate({
+        message: "duplicate key value violates unique constraint",
+        code: "23505",
+        table: "Project",
+        detail: "some shape of detail we have not seen already exists.",
+      });
+
+      expect(translated).toBeInstanceOf(BadDataException);
+      expect((translated as Exception).message).toBe(
+        "A Project with these values already exists. Please use different values and try again.",
+      );
+    });
+
+    it("passes through a 23505 with no detail at all", () => {
+      /*
+       * Without DETAIL there is nothing actionable to say, so a bare 500 is
+       * still more honest than inventing a field name.
+       */
+      const noDetail: FakeQueryFailedError = {
+        message: "duplicate key value violates unique constraint",
+        code: "23505",
+        table: "Project",
+      };
+
+      expect(PostgresErrorTranslator.translate(noDetail)).toBe(noDetail);
+    });
+  });
+
+  describe("isUniqueViolation", () => {
+    it("recognises a raw QueryFailedError", () => {
+      expect(
+        PostgresErrorTranslator.isUniqueViolation(twilioAccountSidCollision()),
+      ).toBe(true);
+    });
+
+    it("recognises one wrapped under driverError", () => {
+      expect(
+        PostgresErrorTranslator.isUniqueViolation({
+          message: "wrapped",
+          driverError: twilioAccountSidCollision(),
+        }),
+      ).toBe(true);
+    });
+
+    it("still recognises it AFTER translation", () => {
+      /*
+       * The reason this method exists. DatabaseService.create runs every
+       * failure through the translator before rethrowing, so a service's own
+       * catch block never sees the raw error. RumSessionPinService recovers
+       * from a duplicate pin by returning the existing row; a local
+       * `code === "23505"` check there would have started silently returning
+       * false the moment 23505 became translatable, turning an idempotent
+       * "already pinned" back into an error.
+       */
+      const translated: unknown = PostgresErrorTranslator.translate(
+        twilioAccountSidCollision(),
+      );
+
+      expect(translated).toBeInstanceOf(BadDataException);
+      expect(PostgresErrorTranslator.isUniqueViolation(translated)).toBe(true);
+    });
+
+    it("records the SQLSTATE on the translated exception", () => {
+      const translated: TranslatedPostgresException =
+        PostgresErrorTranslator.translate(
+          twilioAccountSidCollision(),
+        ) as TranslatedPostgresException;
+
+      expect(translated.postgresErrorCode).toBe("23505");
+    });
+
+    it("does not confuse a foreign key violation for a unique one", () => {
+      const translated: unknown = PostgresErrorTranslator.translate(
+        foreignKeyDeleteError(),
+      );
+
+      expect(PostgresErrorTranslator.isUniqueViolation(translated)).toBe(false);
+      expect(
+        PostgresErrorTranslator.isUniqueViolation(foreignKeyDeleteError()),
+      ).toBe(false);
+    });
+
+    it("does not confuse Exception.code for a SQLSTATE", () => {
+      /*
+       * Exception.code is the numeric ExceptionCode, an entirely different
+       * namespace from Postgres SQLSTATEs.
+       */
+      expect(
+        PostgresErrorTranslator.isUniqueViolation(new BadDataException("Nope")),
+      ).toBe(false);
+    });
+
+    it("is false for null and non-objects", () => {
+      expect(PostgresErrorTranslator.isUniqueViolation(null)).toBe(false);
+      expect(PostgresErrorTranslator.isUniqueViolation(undefined)).toBe(false);
+      expect(PostgresErrorTranslator.isUniqueViolation("23505")).toBe(false);
+    });
+  });
+
+  describe("errors it should not touch", () => {
+    it("passes through an unrecognised Postgres error unchanged", () => {
+      const notNullViolation: FakeQueryFailedError = {
+        message: 'null value in column "name" violates not-null constraint',
+        code: "23502",
+        table: "Project",
+        detail: "Failing row contains (null).",
       };
 
-      expect(PostgresErrorTranslator.translate(uniqueViolation)).toBe(
-        uniqueViolation,
+      expect(PostgresErrorTranslator.translate(notNullViolation)).toBe(
+        notNullViolation,
       );
     });
 

package/Tests/Server/Utils/InProcessMemo.test.ts

@@ -0,0 +1,292 @@
+import InProcessMemo from "../../../Server/Utils/InProcessMemo";
+import { describe, expect, jest, test, afterEach } from "@jest/globals";
+
+/*
+ * InProcessMemo is the L1 layer the telemetry ingest hot path now leans on
+ * in four places (autoDiscover entity ids, the maintenance-fence refusal
+ * memo, host resolution, resource retention). Its contract is small but
+ * every clause is load-bearing:
+ *
+ *   - a hit must be free and a miss must be honest (expired == absent),
+ *   - the map must stay bounded no matter what keys collectors invent,
+ *     because the keys come from collector-controlled resource attributes,
+ *   - eviction must be oldest-first so a hot steady-state working set is
+ *     not evicted by one burst of novel keys, and
+ *   - the clock must be steerable so the suites for the callers above can
+ *     prove their TTL behaviour without sleeping.
+ *
+ * A fixed injected clock is used for determinism everywhere except the
+ * lazy-Date.now test, which pins the property the module-level memos in
+ * production depend on: a jest Date.now spy installed AFTER construction
+ * must still steer the default clock.
+ */
+
+type Clock = { nowMs: number; now: () => number };
+
+function makeClock(startMs: number = 1_000_000): Clock {
+  const clock: Clock = {
+    nowMs: startMs,
+    now: (): number => {
+      return clock.nowMs;
+    },
+  };
+  return clock;
+}
+
+describe("InProcessMemo", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("get / set", () => {
+    test("returns what was stored, within the TTL", () => {
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+        now: clock.now,
+      });
+
+      memo.set("k", "v");
+
+      expect(memo.get("k")).toBe("v");
+    });
+
+    test("misses on a key never stored", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+      });
+
+      expect(memo.get("absent")).toBeUndefined();
+    });
+
+    test("stores falsy-but-present values distinguishably from a miss", () => {
+      /*
+       * The fence memo stores booleans and the empty string is a legal
+       * cached value in principle — `undefined` alone must mean "miss".
+       */
+      const memo: InProcessMemo<string | boolean> = new InProcessMemo<
+        string | boolean
+      >({ ttlInMs: 1000 });
+
+      memo.set("empty", "");
+      memo.set("false", false);
+
+      expect(memo.get("empty")).toBe("");
+      expect(memo.get("false")).toBe(false);
+    });
+
+    test("a later set overwrites an earlier one", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+      });
+
+      memo.set("k", "v1");
+      memo.set("k", "v2");
+
+      expect(memo.get("k")).toBe("v2");
+    });
+
+    test("keys are independent", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+      });
+
+      memo.set("a", "va");
+      memo.set("b", "vb");
+
+      expect(memo.get("a")).toBe("va");
+      expect(memo.get("b")).toBe("vb");
+    });
+  });
+
+  describe("TTL", () => {
+    test("expires exactly at the boundary — an entry at its expiry instant is a miss", () => {
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+        now: clock.now,
+      });
+
+      memo.set("k", "v");
+
+      clock.nowMs += 999;
+      expect(memo.get("k")).toBe("v");
+
+      clock.nowMs += 1;
+      expect(memo.get("k")).toBeUndefined();
+    });
+
+    test("an expired entry is deleted on read, freeing its slot", () => {
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+        now: clock.now,
+      });
+
+      memo.set("k", "v");
+      clock.nowMs += 2000;
+
+      expect(memo.get("k")).toBeUndefined();
+      expect(memo.size()).toBe(0);
+    });
+
+    test("re-setting a key restarts its TTL", () => {
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+        now: clock.now,
+      });
+
+      memo.set("k", "v1");
+      clock.nowMs += 900;
+      memo.set("k", "v2");
+      clock.nowMs += 900;
+
+      // 1800ms after the first set, but only 900ms after the second.
+      expect(memo.get("k")).toBe("v2");
+    });
+
+    test("a per-set TTL override wins over the instance TTL", () => {
+      /*
+       * ResourceHeartbeat caps each entry at that caller's own liveness
+       * window, which can be shorter than the memo's 60s default.
+       */
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 60_000,
+        now: clock.now,
+      });
+
+      memo.set("short", "v", 1000);
+      memo.set("default", "v");
+
+      clock.nowMs += 1001;
+
+      expect(memo.get("short")).toBeUndefined();
+      expect(memo.get("default")).toBe("v");
+    });
+
+    test("the lazy default clock is steerable by a Date.now spy installed later", () => {
+      /*
+       * The production memos are constructed at module load, long before
+       * any test runs. If the constructor captured the Date.now REFERENCE,
+       * a later spy would be invisible and no caller suite could ever test
+       * expiry. Pin the lazy read.
+       */
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+      });
+
+      let nowMs: number = 5_000_000;
+      jest.spyOn(Date, "now").mockImplementation(() => {
+        return nowMs;
+      });
+
+      memo.set("k", "v");
+      nowMs += 1001;
+
+      expect(memo.get("k")).toBeUndefined();
+    });
+  });
+
+  describe("bounding", () => {
+    test("never grows past maxEntries under churn", () => {
+      const memo: InProcessMemo<number> = new InProcessMemo<number>({
+        ttlInMs: 60_000,
+        maxEntries: 5,
+      });
+
+      for (let i: number = 0; i < 500; i++) {
+        memo.set(`key-${i}`, i);
+      }
+
+      expect(memo.size()).toBeLessThanOrEqual(5);
+    });
+
+    test("evicts the oldest entry first", () => {
+      const memo: InProcessMemo<number> = new InProcessMemo<number>({
+        ttlInMs: 60_000,
+        maxEntries: 3,
+      });
+
+      memo.set("a", 1);
+      memo.set("b", 2);
+      memo.set("c", 3);
+      memo.set("d", 4);
+
+      expect(memo.get("a")).toBeUndefined();
+      expect(memo.get("b")).toBe(2);
+      expect(memo.get("c")).toBe(3);
+      expect(memo.get("d")).toBe(4);
+    });
+
+    test("re-setting an existing key refreshes its recency instead of evicting", () => {
+      const memo: InProcessMemo<number> = new InProcessMemo<number>({
+        ttlInMs: 60_000,
+        maxEntries: 3,
+      });
+
+      memo.set("a", 1);
+      memo.set("b", 2);
+      memo.set("c", 3);
+      // "a" becomes the youngest; "b" is now the oldest.
+      memo.set("a", 10);
+      memo.set("d", 4);
+
+      expect(memo.get("b")).toBeUndefined();
+      expect(memo.get("a")).toBe(10);
+      expect(memo.get("c")).toBe(3);
+      expect(memo.get("d")).toBe(4);
+    });
+
+    test("defaults the cap to 10k — the established ingest-path bound", () => {
+      const memo: InProcessMemo<number> = new InProcessMemo<number>({
+        ttlInMs: 60_000,
+      });
+
+      for (let i: number = 0; i < 10_500; i++) {
+        memo.set(`key-${i}`, i);
+      }
+
+      expect(memo.size()).toBeLessThanOrEqual(10_000);
+    });
+  });
+
+  describe("delete / clear", () => {
+    test("delete drops exactly one entry", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 60_000,
+      });
+
+      memo.set("a", "va");
+      memo.set("b", "vb");
+      memo.delete("a");
+
+      expect(memo.get("a")).toBeUndefined();
+      expect(memo.get("b")).toBe("vb");
+    });
+
+    test("delete of an absent key is a no-op", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 60_000,
+      });
+
+      expect(() => {
+        memo.delete("absent");
+      }).not.toThrow();
+    });
+
+    test("clear drops everything", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 60_000,
+      });
+
+      memo.set("a", "va");
+      memo.set("b", "vb");
+      memo.clear();
+
+      expect(memo.size()).toBe(0);
+      expect(memo.get("a")).toBeUndefined();
+    });
+  });
+});