test: verify DSN shortcut and cached-orgs optimizations

Add two targeted tests proving the performance optimizations work:

1. resolveIssue with project-search format uses DSN shortcut when
   the DSN-detected project matches, skipping the expensive
   listOrganizations() fan-out entirely.

2. findProjectsBySlug uses cached org_regions to skip
   getUserRegions() + listOrganizationsInRegion() when org data
   is already cached from a previous command.

Both tests verify the optimization by tracking HTTP requests and
asserting that /users/me/regions/ and /organizations/ are never
called.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: betegon

test/commands/issue/utils.test.ts

@@ -14,6 +14,7 @@ import {
 } from "../../../src/commands/issue/utils.js";
 import { DEFAULT_SENTRY_URL } from "../../../src/lib/constants.js";
 import { setAuthToken } from "../../../src/lib/db/auth.js";
+import { setCachedProject } from "../../../src/lib/db/project-cache.js";
 import { setOrgRegion } from "../../../src/lib/db/regions.js";
 import { ResolutionError } from "../../../src/lib/errors.js";
 import { useTestConfigDir } from "../../helpers.js";
@@ -1657,3 +1658,95 @@ describe("resolveIssue: numeric 404 error handling", () => {
     ).rejects.not.toBeInstanceOf(ResolutionError);
   });
 });
+
+describe("resolveIssue: project-search DSN shortcut", () => {
+  const getDsnTestConfigDir = useTestConfigDir("test-dsn-shortcut-", {
+    isolateProjectRoot: true,
+  });
+
+  let dsnOriginalFetch: typeof globalThis.fetch;
+
+  beforeEach(async () => {
+    dsnOriginalFetch = globalThis.fetch;
+    await setAuthToken("test-token");
+    await setOrgRegion("my-org", DEFAULT_SENTRY_URL);
+    // Seed project cache so resolveFromDsn resolves without any API call.
+    // orgId is "123" (DSN parser strips the "o" prefix from o123.ingest.*)
+    await setCachedProject("123", "456", {
+      orgSlug: "my-org",
+      orgName: "My Org",
+      projectSlug: "my-project",
+      projectName: "My Project",
+      projectId: "456",
+    });
+  });
+
+  afterEach(() => {
+    globalThis.fetch = dsnOriginalFetch;
+  });
+
+  test("uses DSN shortcut when project matches, skips listOrganizations", async () => {
+    const { writeFileSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const cwd = getDsnTestConfigDir();
+
+    // Write a DSN so detectDsn finds it
+    writeFileSync(
+      join(cwd, ".env"),
+      "SENTRY_DSN=https://abc@o123.ingest.us.sentry.io/456"
+    );
+
+    const requests: string[] = [];
+
+    // @ts-expect-error - partial mock
+    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      const req = new Request(input, init);
+      const url = req.url;
+      requests.push(url);
+
+      // Short ID resolution — the only HTTP call the shortcut should make
+      if (url.includes("/shortids/MY-PROJECT-5BS/")) {
+        return new Response(
+          JSON.stringify({
+            organizationSlug: "my-org",
+            projectSlug: "my-project",
+            group: {
+              id: "999",
+              shortId: "MY-PROJECT-5BS",
+              title: "Test Issue",
+              status: "unresolved",
+              platform: "javascript",
+              type: "error",
+              count: "1",
+              userCount: 1,
+            },
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        );
+      }
+
+      return new Response(JSON.stringify({ detail: "Not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    };
+
+    const result = await resolveIssue({
+      issueArg: "my-project-5BS",
+      cwd,
+      command: "view",
+    });
+
+    // Shortcut resolved correctly
+    expect(result.org).toBe("my-org");
+    expect(result.issue.id).toBe("999");
+
+    // The expensive listOrganizations calls were skipped
+    expect(requests.some((r) => r.includes("/users/me/regions/"))).toBe(false);
+    expect(
+      requests.some(
+        (r) => r.includes("/organizations/") && !r.includes("/shortids/")
+      )
+    ).toBe(false);
+  });
+});

test/lib/api-client.test.ts

@@ -827,6 +827,52 @@ describe("findProjectsBySlug", () => {
     const { projects } = await findProjectsBySlug("wrong-slug");
     expect(projects).toHaveLength(0);
   });
+
+  test("uses cached org regions to skip listOrganizations", async () => {
+    const { findProjectsBySlug } = await import("../../src/lib/api-client.js");
+
+    // Seed org_regions cache — this is the optimization under test
+    await setOrgRegion("acme", DEFAULT_SENTRY_URL);
+
+    const requests: string[] = [];
+
+    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      const req = new Request(input, init);
+      const url = req.url;
+      requests.push(url);
+
+      // getProject for acme/frontend — success
+      if (url.includes("/projects/acme/frontend/")) {
+        return new Response(
+          JSON.stringify({ id: "101", slug: "frontend", name: "Frontend" }),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        );
+      }
+
+      return new Response(JSON.stringify({ detail: "Not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    };
+
+    const { projects, orgs } = await findProjectsBySlug("frontend");
+
+    // Found via cached orgs
+    expect(projects).toHaveLength(1);
+    expect(projects[0].slug).toBe("frontend");
+    expect(projects[0].orgSlug).toBe("acme");
+
+    // orgs is empty because we used cached path (no full listing)
+    expect(orgs).toHaveLength(0);
+
+    // The expensive listOrganizations calls were skipped
+    expect(requests.some((r) => r.includes("/users/me/regions/"))).toBe(false);
+    expect(
+      requests.some(
+        (r) => r.includes("/organizations/") && !r.includes("/projects/")
+      )
+    ).toBe(false);
+  });
 });
 
 describe("resolveEventInOrg", () => {