Generated with Hive: Add recursive pagination to useRepoBranches and update mock API and tests

.github/workflows/deployPR.yml

@@ -109,6 +109,12 @@ jobs:
                 echo "$response"
                 return 0
               fi
+              # Fast-fail on permanent "not found" errors — retrying will not help
+              if echo "$response" | jq -r '.message // empty' 2>/dev/null | grep -qi "not found"; then
+                echo "⚠️  Neon API permanent error for $url — got: ${response:0:120}" >&2
+                echo "$response"
+                return 1
+              fi
               echo "⚠️  Neon API bad/empty response (attempt $attempt/5) for $url — got: ${response:0:120}" >&2
               sleep 10
             done
@@ -192,7 +198,16 @@ jobs:
 
           # Wait until endpoint is ready (GET endpoint does not return credentials)
           for i in {1..30}; do
-            STATUS=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints/$ENDPOINT_ID" "endpoint")
+            STATUS=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints/$ENDPOINT_ID" "endpoint") || {
+              # Endpoint may have been deleted externally (race condition / concurrent run)
+              if echo "$STATUS" | grep -q "not found"; then
+                echo "⚠️  Endpoint $ENDPOINT_ID was deleted mid-wait, will recreate..."
+                ENDPOINT_ID=""
+                break
+              fi
+              echo "❌ Failed to poll endpoint status after retries"
+              exit 1
+            }
             STATE=$(echo "$STATUS" | jq -r '.endpoint.current_state')
             DB_HOST=$(echo "$STATUS" | jq -r '.endpoint.host')
             if [ "$STATE" = "ready" ] && [ -n "$DB_HOST" ] && [ "$DB_HOST" != "null" ]; then
@@ -202,6 +217,82 @@ jobs:
             sleep 3
           done
 
+          # If endpoint disappeared during the wait loop, find or create a replacement
+          if [ -z "$ENDPOINT_ID" ] || [ "$ENDPOINT_ID" = "null" ]; then
+            echo "🔄 Re-fetching branches and endpoints to find/create a replacement..."
+
+            # The branch itself may have been deleted — re-verify and recreate if needed
+            BRANCHES_JSON=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/branches" "branches")
+            BRANCH_ID=$(echo "$BRANCHES_JSON" | jq -r ".branches[] | select(.name==\"$BRANCH_NAME\") | .id")
+
+            if [ -z "$BRANCH_ID" ] || [ "$BRANCH_ID" = "null" ]; then
+              echo "⚠️  Branch $BRANCH_NAME no longer exists — recreating..."
+              RESPONSE=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/branches" "branch" \
+                -X POST \
+                -H "Content-Type: application/json" \
+                -d "{\"branch\":{\"name\":\"$BRANCH_NAME\",\"parent_id\":\"$PARENT_BRANCH_ID\",\"expires_at\":\"$EXPIRY\"}}")
+              BRANCH_ID=$(echo "$RESPONSE" | jq -r '.branch.id')
+              if [ -z "$BRANCH_ID" ] || [ "$BRANCH_ID" = "null" ]; then
+                echo "❌ Failed to recreate branch $BRANCH_NAME"
+                exit 1
+              fi
+              echo "✅ Branch recreated: $BRANCH_ID"
+              # Wait for the new branch to be ready
+              for i in {1..20}; do
+                BRANCH_STATUS=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/branches/$BRANCH_ID" "branch")
+                STATE=$(echo "$BRANCH_STATUS" | jq -r '.branch.current_state')
+                if [ "$STATE" = "ready" ]; then break; fi
+                echo "Waiting for recreated branch... ($i)"
+                sleep 3
+              done
+            fi
+
+            ENDPOINTS_JSON=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints" "endpoints")
+            ENDPOINT_ID=$(echo "$ENDPOINTS_JSON" | jq -r ".endpoints[] | select(.branch_id==\"$BRANCH_ID\") | .id")
+
+            if [ -z "$ENDPOINT_ID" ] || [ "$ENDPOINT_ID" = "null" ]; then
+              RESPONSE=$(curl -s -H "Authorization: Bearer $NEON_API_KEY" \
+                -X POST -H "Content-Type: application/json" \
+                -d "{\"endpoint\":{\"branch_id\":\"$BRANCH_ID\",\"type\":\"read_write\"}}" \
+                "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints")
+
+              if echo "$RESPONSE" | jq -e '.endpoint' > /dev/null 2>&1; then
+                ENDPOINT_ID=$(echo "$RESPONSE" | jq -r '.endpoint.id')
+              else
+                echo "⚠️  Endpoint creation failed: $(echo "$RESPONSE" | jq -r '.message // .code // empty')"
+                echo "♻️  Looking for a stale endpoint to reassign..."
+                STALE_ENDPOINT_ID=$(echo "$ENDPOINTS_JSON" | jq -r \
+                  --arg bid "$BRANCH_ID" \
+                  --arg pbid "$PARENT_BRANCH_ID" \
+                  '.endpoints[] | select(.branch_id != $bid and .branch_id != $pbid and .type == "read_write") | .id' \
+                  | head -1)
+                if [ -z "$STALE_ENDPOINT_ID" ] || [ "$STALE_ENDPOINT_ID" = "null" ]; then
+                  echo "❌ No stale endpoint available to reassign"
+                  exit 1
+                fi
+                echo "♻️  Reassigning endpoint $STALE_ENDPOINT_ID to branch $BRANCH_ID..."
+                RESPONSE=$(neon_curl \
+                  "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints/$STALE_ENDPOINT_ID" "endpoint" \
+                  -X PATCH \
+                  -H "Content-Type: application/json" \
+                  -d "{\"endpoint\":{\"branch_id\":\"$BRANCH_ID\"}}")
+                ENDPOINT_ID=$(echo "$RESPONSE" | jq -r '.endpoint.id')
+              fi
+            fi
+
+            # Wait for the replacement endpoint to be ready
+            for i in {1..30}; do
+              STATUS=$(neon_curl "https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID/endpoints/$ENDPOINT_ID" "endpoint")
+              STATE=$(echo "$STATUS" | jq -r '.endpoint.current_state')
+              DB_HOST=$(echo "$STATUS" | jq -r '.endpoint.host')
+              if [ "$STATE" = "ready" ] && [ -n "$DB_HOST" ] && [ "$DB_HOST" != "null" ]; then
+                break
+              fi
+              echo "Waiting for replacement endpoint... ($i)"
+              sleep 3
+            done
+          fi
+
           if [ -z "$DB_HOST" ] || [ "$DB_HOST" = "null" ]; then
             echo "❌ Endpoint never became ready"
             exit 1
@@ -426,16 +517,27 @@ jobs:
         uses: actions/github-script@v7
         with:
           script: |
-            const deployment = await github.rest.repos.createDeployment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              ref: context.sha,
-              environment: `preview-${{ github.event.pull_request.number }}`,
-              auto_merge: false,
-              required_contexts: [],
-              description: 'PR preview deployment'
-            });
-            return deployment.data.id;
+            const maxAttempts = 5;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+              try {
+                const deployment = await github.rest.repos.createDeployment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  ref: context.sha,
+                  environment: `preview-${{ github.event.pull_request.number }}`,
+                  auto_merge: false,
+                  required_contexts: [],
+                  description: 'PR preview deployment'
+                });
+                return deployment.data.id;
+              } catch (err) {
+                console.log(`Attempt ${attempt}/${maxAttempts} failed: ${err.status} ${err.message}`);
+                if (attempt === maxAttempts) throw err;
+                const wait = attempt * 15000;
+                console.log(`Waiting ${wait / 1000}s before retry...`);
+                await new Promise(r => setTimeout(r, wait));
+              }
+            }
 
       - name: Mark Success
         if: success() && steps.deployment.outputs.result

.github/workflows/e2e.yml

@@ -162,7 +162,7 @@ jobs:
         run: npm ci
 
       - name: Download Playwright Blob Reports
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
         continue-on-error: true
         with:
           pattern: playwright-blob-*

src/__tests__/unit/hooks/useRepoBranches.test.ts

@@ -10,6 +10,14 @@ const MOCK_BRANCHES = [
   { name: "dev", sha: "def456" },
 ];
 
+/** Build an array of N mock branches */
+function makeBranches(count: number, offset = 0) {
+  return Array.from({ length: count }, (_, i) => ({
+    name: `branch-${offset + i}`,
+    sha: `sha-${offset + i}`,
+  }));
+}
+
 describe("useRepoBranches", () => {
   beforeEach(() => {
     vi.stubGlobal("fetch", vi.fn());
@@ -41,6 +49,11 @@ describe("useRepoBranches", () => {
 
     expect(result.current.branches).toEqual(MOCK_BRANCHES);
     expect(result.current.error).toBeNull();
+    // Single page (< 100 items) — only one fetch call
+    expect(fetch).toHaveBeenCalledTimes(1);
+    const calledUrl = vi.mocked(fetch).mock.calls[0][0] as string;
+    expect(calledUrl).toContain("page=1");
+    expect(calledUrl).toContain("per_page=100");
   });
 
   it("sets isLoading true during fetch and false after", async () => {
@@ -155,4 +168,140 @@ describe("useRepoBranches", () => {
     await waitFor(() => expect(result.current.branches).toEqual(branches2));
     expect(fetch).toHaveBeenCalledTimes(2);
   });
+
+  // --- Pagination tests ---
+
+  it("fetches multiple pages and accumulates all branches (100 + 40 = 140)", async () => {
+    const page1 = makeBranches(100, 0);
+    const page2 = makeBranches(40, 100);
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ branches: page1 }),
+      } as Response)
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ branches: page2 }),
+      } as Response);
+
+    const { result } = renderHook(() =>
+      useRepoBranches(REPO_URL, WORKSPACE_SLUG),
+    );
+
+    act(() => { result.current.fetchBranches(); });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.branches).toHaveLength(140);
+    expect(result.current.branches).toEqual([...page1, ...page2]);
+    expect(fetch).toHaveBeenCalledTimes(2);
+
+    const call1Url = vi.mocked(fetch).mock.calls[0][0] as string;
+    const call2Url = vi.mocked(fetch).mock.calls[1][0] as string;
+    expect(call1Url).toContain("page=1");
+    expect(call2Url).toContain("page=2");
+    expect(call1Url).toContain("per_page=100");
+    expect(call2Url).toContain("per_page=100");
+  });
+
+  it("continues fetching when page returns exactly 100 items, stops on empty next page", async () => {
+    const page1 = makeBranches(100, 0);
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ branches: page1 }),
+      } as Response)
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ branches: [] }),
+      } as Response);
+
+    const { result } = renderHook(() =>
+      useRepoBranches(REPO_URL, WORKSPACE_SLUG),
+    );
+
+    act(() => { result.current.fetchBranches(); });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.branches).toHaveLength(100);
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("stops after one fetch when page 1 returns fewer than 100 items", async () => {
+    const page1 = makeBranches(42, 0);
+
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ branches: page1 }),
+    } as Response);
+
+    const { result } = renderHook(() =>
+      useRepoBranches(REPO_URL, WORKSPACE_SLUG),
+    );
+
+    act(() => { result.current.fetchBranches(); });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.branches).toHaveLength(42);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("fetches three pages and accumulates all branches (100 + 100 + 50 = 250)", async () => {
+    const page1 = makeBranches(100, 0);
+    const page2 = makeBranches(100, 100);
+    const page3 = makeBranches(50, 200);
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ branches: page1 }),
+      } as Response)
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ branches: page2 }),
+      } as Response)
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ branches: page3 }),
+      } as Response);
+
+    const { result } = renderHook(() =>
+      useRepoBranches(REPO_URL, WORKSPACE_SLUG),
+    );
+
+    act(() => { result.current.fetchBranches(); });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.branches).toHaveLength(250);
+    expect(fetch).toHaveBeenCalledTimes(3);
+
+    const call3Url = vi.mocked(fetch).mock.calls[2][0] as string;
+    expect(call3Url).toContain("page=3");
+  });
+
+  it("does not re-fetch for the same repoUrl + workspaceSlug (cache)", async () => {
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ branches: MOCK_BRANCHES }),
+    } as Response);
+
+    const { result } = renderHook(() =>
+      useRepoBranches(REPO_URL, WORKSPACE_SLUG),
+    );
+
+    act(() => { result.current.fetchBranches(); });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    // Second call — should be a no-op due to cache
+    act(() => { result.current.fetchBranches(); });
+
+    // Still only 1 fetch total
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(result.current.branches).toEqual(MOCK_BRANCHES);
+  });
 });

src/__tests__/unit/services/notifications.test.ts

@@ -177,21 +177,21 @@ describe("createAndSendNotification", () => {
       findFirst.mockResolvedValue(null);
       create.mockResolvedValue(mockRecord);
       userFindUnique.mockResolvedValue(userWithPubkey);
-      update.mockResolvedValue({ ...mockRecord });
 
       await createAndSendNotification(baseInput);
 
-      expect(create).toHaveBeenCalledOnce();
-      expect(mockedSendDirectMessage).not.toHaveBeenCalled();
-      expect(update).toHaveBeenCalledWith(
+      // sendAfter + message are now written atomically in the create call, so no
+      // separate update call should happen for deferred notification types.
+      expect(create).toHaveBeenCalledWith(
         expect.objectContaining({
-          where: { id: "notif-1" },
           data: expect.objectContaining({
             sendAfter: expect.any(Date),
             message: baseInput.message,
           }),
         })
       );
+      expect(mockedSendDirectMessage).not.toHaveBeenCalled();
+      expect(update).not.toHaveBeenCalled();
     });
   });
 

src/app/api/mock/github/repos/[owner]/[repo]/branches/route.ts

@@ -30,7 +30,12 @@ export async function GET(
       repository = mockGitHubState.createRepository(owner, repo);
     }
 
-    const branches = mockGitHubState.getBranches(owner, repo);
+    const page = Math.max(1, parseInt(request.nextUrl.searchParams.get("page") ?? "1", 10));
+    const perPage = Math.max(1, parseInt(request.nextUrl.searchParams.get("per_page") ?? "100", 10));
+
+    const allBranches = mockGitHubState.getBranches(owner, repo);
+    const start = (page - 1) * perPage;
+    const branches = allBranches.slice(start, start + perPage);
     return NextResponse.json(branches);
   } catch (error) {
     console.error("Mock GitHub branches error:", error);

src/app/api/mock/seed-branches/route.ts

@@ -0,0 +1,14 @@
+import { NextRequest, NextResponse } from "next/server";
+import { mockGitHubState } from "@/lib/mock/github-state";
+
+export async function POST(request: NextRequest) {
+  const { owner, repo, branches } = await request.json();
+  if (!mockGitHubState.getRepository(owner, repo)) {
+    mockGitHubState.createRepository(owner, repo);
+  }
+  for (const name of branches) {
+    mockGitHubState.createBranch(owner, repo, name, false);
+  }
+  const all = mockGitHubState.getBranches(owner, repo);
+  return NextResponse.json({ count: all.length, branches: all.map(b => b.name) });
+}