@oneuptime/common 12.0.5 → 12.0.7

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

@@ -0,0 +1,393 @@
+/*
+ * ---------------------------------------------------------------------------
+ * GitHubUtil.createPullRequestWithToken — the App-authenticated create-PR
+ * path used by the chat toolbox (open_code_pull_request) and by the
+ * server-side fix triggers.
+ *
+ * The invariant pinned here: the pull request opens READY FOR REVIEW. A draft
+ * reaches no reviewer, no CODEOWNERS rule and no review automation, so an
+ * agent that drafted by default was burying its own output where nobody was
+ * asked to look.
+ *
+ * This is a VISIBILITY change and not a safety one. The safety boundary lives
+ * in the branch policy (never the default branch, never a protected branch,
+ * asserted in CodeWriteTools.test.ts) and in the fact that nothing is ever
+ * merged automatically. Ready for review still means unreviewed.
+ *
+ * The isDraft option and its 422 fallback survive for callers that still want
+ * a draft — but the fallback must fire ONLY on a 422 that names drafts.
+ * GitHub answers 422 for "a pull request already exists for this branch" too,
+ * and blindly retrying that produced a second identical failure whose message
+ * no longer described the real problem.
+ * ---------------------------------------------------------------------------
+ */
+
+import GitHubUtil from "../../../Server/Utils/CodeRepository/GitHub/GitHub";
+import API from "../../../Utils/API";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import { JSONObject } from "../../../Types/JSON";
+import PullRequest from "../../../Types/CodeRepository/PullRequest";
+import PullRequestState from "../../../Types/CodeRepository/PullRequestState";
+import { describe, expect, test, beforeEach, afterEach } from "@jest/globals";
+
+const CREATE_ARGS: {
+  installationId: string;
+  organizationName: string;
+  repositoryName: string;
+  baseBranchName: string;
+  headBranchName: string;
+  title: string;
+  body: string;
+} = {
+  installationId: "installation-1",
+  organizationName: "acme",
+  repositoryName: "checkout",
+  baseBranchName: "main",
+  headBranchName: "oneuptime-ai/fix-charge",
+  title: "fix: guard the undefined cart",
+  body: "why this change",
+};
+
+// GitHub's create-PR 201 body, trimmed to the fields the mapper reads.
+function prCreatedResponse(): HTTPResponse<JSONObject> {
+  return new HTTPResponse<JSONObject>(
+    201,
+    {
+      id: 4242,
+      number: 7,
+      title: "fix: guard the undefined cart",
+      body: "why this change",
+      url: "https://api.github.com/repos/acme/checkout/pulls/7",
+      state: "open",
+      created_at: "2026-08-11T10:00:00Z",
+      updated_at: "2026-08-11T10:00:00Z",
+      head: { ref: "oneuptime-ai/fix-charge" },
+      base: { ref: "main" },
+    },
+    {},
+  );
+}
+
+function errorResponse(
+  statusCode: number,
+  data: JSONObject,
+): HTTPErrorResponse {
+  return new HTTPErrorResponse(statusCode, data, {});
+}
+
+function draftsNotSupported(): HTTPErrorResponse {
+  return errorResponse(422, {
+    message: "Draft pull requests are not supported in this repository.",
+  });
+}
+
+function pullRequestAlreadyExists(): HTTPErrorResponse {
+  return errorResponse(422, {
+    message: "Validation Failed",
+    errors: [
+      {
+        resource: "PullRequest",
+        code: "custom",
+        message:
+          "A pull request already exists for acme:oneuptime-ai/fix-charge.",
+      },
+    ],
+  });
+}
+
+let postSpy: jest.SpiedFunction<typeof API.post>;
+
+// The body of the Nth API.post call, 1-indexed to match how retries read.
+function requestBody(callNumber: number): JSONObject {
+  const args: unknown = postSpy.mock.calls[callNumber - 1];
+
+  if (!args) {
+    throw new Error(`API.post was not called ${callNumber} time(s)`);
+  }
+
+  return (args as Array<{ data: JSONObject }>)[0]!.data;
+}
+
+describe("GitHubUtil.createPullRequestWithToken", () => {
+  beforeEach(() => {
+    jest
+      .spyOn(GitHubUtil, "getInstallationAccessToken")
+      .mockResolvedValue({ token: "gh-token", expiresAt: new Date() });
+
+    postSpy = jest.spyOn(API, "post");
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("the default", () => {
+    test("opens the pull request READY FOR REVIEW, not as a draft", async () => {
+      postSpy.mockResolvedValueOnce(prCreatedResponse());
+
+      await GitHubUtil.createPullRequestWithToken(CREATE_ARGS);
+
+      expect(postSpy).toHaveBeenCalledTimes(1);
+      expect(requestBody(1)["draft"]).toBe(false);
+    });
+
+    /*
+     * Sent explicitly rather than omitted: GitHub's own default is non-draft
+     * today, but leaving the field out makes the intent unassertable and
+     * dependent on their default staying put.
+     */
+    test("sends draft explicitly rather than relying on GitHub's default", async () => {
+      postSpy.mockResolvedValueOnce(prCreatedResponse());
+
+      await GitHubUtil.createPullRequestWithToken(CREATE_ARGS);
+
+      expect(Object.keys(requestBody(1))).toContain("draft");
+    });
+
+    test("sends the branches, title and body alongside it", async () => {
+      postSpy.mockResolvedValueOnce(prCreatedResponse());
+
+      await GitHubUtil.createPullRequestWithToken(CREATE_ARGS);
+
+      expect(requestBody(1)).toEqual({
+        base: "main",
+        head: "oneuptime-ai/fix-charge",
+        title: "fix: guard the undefined cart",
+        body: "why this change",
+        draft: false,
+      });
+    });
+
+    test("returns the mapped pull request", async () => {
+      postSpy.mockResolvedValueOnce(prCreatedResponse());
+
+      const pullRequest: PullRequest =
+        await GitHubUtil.createPullRequestWithToken(CREATE_ARGS);
+
+      expect(pullRequest.pullRequestId).toBe(4242);
+      expect(pullRequest.pullRequestNumber).toBe(7);
+      expect(pullRequest.state).toBe(PullRequestState.Open);
+      expect(pullRequest.repoOrganizationName).toBe("acme");
+      expect(pullRequest.repoName).toBe("checkout");
+    });
+
+    test("requests a token scoped to pull requests and contents", async () => {
+      postSpy.mockResolvedValueOnce(prCreatedResponse());
+
+      await GitHubUtil.createPullRequestWithToken(CREATE_ARGS);
+
+      expect(GitHubUtil.getInstallationAccessToken).toHaveBeenCalledWith(
+        "installation-1",
+        { permissions: { pull_requests: "write", contents: "write" } },
+      );
+    });
+  });
+
+  describe("the explicit option", () => {
+    test("isDraft: false opens ready for review", async () => {
+      postSpy.mockResolvedValueOnce(prCreatedResponse());
+
+      await GitHubUtil.createPullRequestWithToken({
+        ...CREATE_ARGS,
+        isDraft: false,
+      });
+
+      expect(requestBody(1)["draft"]).toBe(false);
+    });
+
+    // The option is kept, not removed — only the DEFAULT changed.
+    test("isDraft: true still opens a draft", async () => {
+      postSpy.mockResolvedValueOnce(prCreatedResponse());
+
+      await GitHubUtil.createPullRequestWithToken({
+        ...CREATE_ARGS,
+        isDraft: true,
+      });
+
+      expect(requestBody(1)["draft"]).toBe(true);
+    });
+
+    /*
+     * A caller threading an optional through ("isDraft: settings.draft") must
+     * land on ready-for-review. The old default read `!== false`, where
+     * undefined meant draft.
+     */
+    test("isDraft: undefined is ready for review, not a draft", async () => {
+      postSpy.mockResolvedValueOnce(prCreatedResponse());
+
+      await GitHubUtil.createPullRequestWithToken({
+        ...CREATE_ARGS,
+        isDraft: undefined,
+      });
+
+      expect(requestBody(1)["draft"]).toBe(false);
+    });
+  });
+
+  describe("the draft fallback for repositories without the feature", () => {
+    test("retries a rejected draft as ready for review", async () => {
+      postSpy
+        .mockResolvedValueOnce(draftsNotSupported())
+        .mockResolvedValueOnce(prCreatedResponse());
+
+      const pullRequest: PullRequest =
+        await GitHubUtil.createPullRequestWithToken({
+          ...CREATE_ARGS,
+          isDraft: true,
+        });
+
+      expect(postSpy).toHaveBeenCalledTimes(2);
+      expect(requestBody(1)["draft"]).toBe(true);
+      expect(requestBody(2)["draft"]).toBe(false);
+      expect(pullRequest.pullRequestNumber).toBe(7);
+    });
+
+    test("keeps the title, body and branches identical on the retry", async () => {
+      postSpy
+        .mockResolvedValueOnce(draftsNotSupported())
+        .mockResolvedValueOnce(prCreatedResponse());
+
+      await GitHubUtil.createPullRequestWithToken({
+        ...CREATE_ARGS,
+        isDraft: true,
+      });
+
+      expect({ ...requestBody(2), draft: true }).toEqual(requestBody(1));
+    });
+
+    /*
+     * The regression this guards: the retry used to fire on ANY 422. A
+     * duplicate-PR 422 was retried, failed identically, and the caller was
+     * handed the second error — same status, and no longer the real story.
+     */
+    test("does NOT retry a 422 that is not about drafts", async () => {
+      postSpy.mockResolvedValueOnce(pullRequestAlreadyExists());
+
+      await expect(
+        GitHubUtil.createPullRequestWithToken({
+          ...CREATE_ARGS,
+          isDraft: true,
+        }),
+      ).rejects.toBeInstanceOf(HTTPErrorResponse);
+
+      expect(postSpy).toHaveBeenCalledTimes(1);
+    });
+
+    /*
+     * With the default now non-draft there is nothing to fall back FROM, so a
+     * retry here would be a silent duplicate create attempt against GitHub.
+     */
+    test("never retries when the request was not a draft in the first place", async () => {
+      postSpy.mockResolvedValueOnce(draftsNotSupported());
+
+      await expect(
+        GitHubUtil.createPullRequestWithToken(CREATE_ARGS),
+      ).rejects.toBeInstanceOf(HTTPErrorResponse);
+
+      expect(postSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test("does not retry a non-422 failure even when it mentions drafts", async () => {
+      postSpy.mockResolvedValueOnce(
+        errorResponse(403, { message: "Draft access forbidden" }),
+      );
+
+      await expect(
+        GitHubUtil.createPullRequestWithToken({
+          ...CREATE_ARGS,
+          isDraft: true,
+        }),
+      ).rejects.toBeInstanceOf(HTTPErrorResponse);
+
+      expect(postSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test("throws the second failure when the retry also fails", async () => {
+      postSpy.mockResolvedValueOnce(draftsNotSupported()).mockResolvedValueOnce(
+        errorResponse(422, {
+          message: "Validation Failed",
+          errors: [{ message: "head sha can't be blank" }],
+        }),
+      );
+
+      await expect(
+        GitHubUtil.createPullRequestWithToken({
+          ...CREATE_ARGS,
+          isDraft: true,
+        }),
+      ).rejects.toBeInstanceOf(HTTPErrorResponse);
+
+      expect(postSpy).toHaveBeenCalledTimes(2);
+    });
+  });
+});
+
+/*
+ * The predicate behind the fallback, tested directly: it decides whether a
+ * failed create is "this repository has no drafts" or something else that
+ * must not be retried.
+ */
+describe("GitHubUtil.isDraftNotSupportedError", () => {
+  test("true when the 422 message names drafts", () => {
+    expect(GitHubUtil.isDraftNotSupportedError(draftsNotSupported())).toBe(
+      true,
+    );
+  });
+
+  test("true when only the errors array names drafts", () => {
+    expect(
+      GitHubUtil.isDraftNotSupportedError(
+        errorResponse(422, {
+          message: "Validation Failed",
+          errors: [{ message: "Draft pull requests are not supported." }],
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  test("case-insensitive — GitHub capitalizes 'Draft' at the start of a sentence", () => {
+    expect(
+      GitHubUtil.isDraftNotSupportedError(
+        errorResponse(422, { message: "DRAFT PULL REQUESTS UNSUPPORTED" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("false for a duplicate-pull-request 422", () => {
+    expect(
+      GitHubUtil.isDraftNotSupportedError(pullRequestAlreadyExists()),
+    ).toBe(false);
+  });
+
+  test("false for an invalid-head 422", () => {
+    expect(
+      GitHubUtil.isDraftNotSupportedError(
+        errorResponse(422, {
+          message: "Validation Failed",
+          errors: [{ field: "head", code: "invalid" }],
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  test("false for any non-422, even one that mentions drafts", () => {
+    expect(
+      GitHubUtil.isDraftNotSupportedError(
+        errorResponse(403, { message: "Draft access forbidden" }),
+      ),
+    ).toBe(false);
+
+    expect(
+      GitHubUtil.isDraftNotSupportedError(
+        errorResponse(500, { message: "Draft service unavailable" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("false — not a crash — on a 422 with an empty body", () => {
+    expect(GitHubUtil.isDraftNotSupportedError(errorResponse(422, {}))).toBe(
+      false,
+    );
+  });
+});