Merge pull request 'feat: add backend pagination for infinite scroll in issues and pulls' (#66) from feature/pagination-infinite-scroll into master

internal/gitea/client.go

@@ -308,173 +308,243 @@ func (c *Client) ListOrgsAndRepos(ctx context.Context, token string) (map[string
 	return result, nil
 }
 
-// ListAllIssues fetches all open issues across all repos in the given orgs,
+// PageSize is the number of items returned per page for paginated listings.
-// using concurrent requests with a semaphore.
+const PageSize = 20
-func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string) ([]Issue, error) {
-	cacheKey := fmt.Sprintf("issues-%s", strings.Join(orgs, ","))
-	if cached, ok := c.getFromCache(cacheKey); ok {
-		return cached.([]Issue), nil
-	}
 
-	// First, collect all repos for the given orgs.
+// PaginatedIssues holds a page of issues along with pagination metadata.
-	var allRepos []Repo
+type PaginatedIssues struct {
-	for _, org := range orgs {
+	Issues  []Issue
-		repos, err := c.ListOrgRepos(ctx, token, org)
+	HasMore bool
-		if err != nil {
-			return nil, fmt.Errorf("listing repos for %s: %w", org, err)
-		}
-		allRepos = append(allRepos, repos...)
-	}
-
-	// Fan out issue fetching across repos.
-	var allIssues []Issue
-	var mu sync.Mutex
-	sem := make(chan struct{}, c.maxConcurrent)
-	var wg sync.WaitGroup
-	var firstErr error
-
-	for _, repo := range allRepos {
-		wg.Add(1)
-		go func(r Repo) {
-			defer wg.Done()
-			sem <- struct{}{}
-			defer func() { <-sem }()
-
-			path := fmt.Sprintf("/repos/%s/issues?state=open&type=issues&limit=50", r.FullName)
-			resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
-			if err != nil {
-				mu.Lock()
-				if firstErr == nil {
-					firstErr = fmt.Errorf("fetching issues for %s: %w", r.FullName, err)
-				}
-				mu.Unlock()
-				return
-			}
-			defer resp.Body.Close()
-
-			var issues []Issue
-			if err := json.NewDecoder(resp.Body).Decode(&issues); err != nil {
-				mu.Lock()
-				if firstErr == nil {
-					firstErr = fmt.Errorf("decoding issues for %s: %w", r.FullName, err)
-				}
-				mu.Unlock()
-				return
-			}
-
-			// Tag each issue with repo info.
-			for i := range issues {
-				issues[i].RepoOwner = r.Owner.Login
-				issues[i].RepoName = r.Name
-			}
-
-			mu.Lock()
-			allIssues = append(allIssues, issues...)
-			mu.Unlock()
-		}(repo)
-	}
-
-	wg.Wait()
-
-	if firstErr != nil {
-		return nil, firstErr
-	}
-
-	// Sort by updated time, newest first.
-	sort.Slice(allIssues, func(i, j int) bool {
-		return allIssues[i].UpdatedAt.After(allIssues[j].UpdatedAt)
-	})
-
-	c.setCache(cacheKey, allIssues)
-	return allIssues, nil
 }
 
-// ListAllPullRequests fetches all open PRs across all repos in the given orgs.
+// PaginatedPulls holds a page of pull requests along with pagination metadata.
-func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []string) ([]PullRequest, error) {
+type PaginatedPulls struct {
-	cacheKey := fmt.Sprintf("pulls-%s", strings.Join(orgs, ","))
+	Pulls   []PullRequest
+	HasMore bool
+}
+
+// ListAllIssues fetches issues across all repos in the given orgs,
+// using concurrent requests with a semaphore. Results are paginated.
+func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string, state string, page int) (PaginatedIssues, error) {
+	if state == "" {
+		state = "open"
+	}
+	if page < 1 {
+		page = 1
+	}
+
+	cacheKey := fmt.Sprintf("issues-%s-%s", state, strings.Join(orgs, ","))
+	var allIssues []Issue
 	if cached, ok := c.getFromCache(cacheKey); ok {
-		return cached.([]PullRequest), nil
+		allIssues = cached.([]Issue)
-	}
+	} else {
-
+		// First, collect all repos for the given orgs.
-	var allRepos []Repo
+		var allRepos []Repo
-	for _, org := range orgs {
+		for _, org := range orgs {
-		repos, err := c.ListOrgRepos(ctx, token, org)
+			repos, err := c.ListOrgRepos(ctx, token, org)
-		if err != nil {
-			return nil, fmt.Errorf("listing repos for %s: %w", org, err)
-		}
-		allRepos = append(allRepos, repos...)
-	}
-
-	var allPRs []PullRequest
-	var mu sync.Mutex
-	sem := make(chan struct{}, c.maxConcurrent)
-	var wg sync.WaitGroup
-	var firstErr error
-
-	for _, repo := range allRepos {
-		wg.Add(1)
-		go func(r Repo) {
-			defer wg.Done()
-			sem <- struct{}{}
-			defer func() { <-sem }()
-
-			path := fmt.Sprintf("/repos/%s/pulls?state=open&limit=50", r.FullName)
-			resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
 			if err != nil {
-				mu.Lock()
+				return PaginatedIssues{}, fmt.Errorf("listing repos for %s: %w", org, err)
-				if firstErr == nil {
+			}
-					firstErr = fmt.Errorf("fetching PRs for %s: %w", r.FullName, err)
+			allRepos = append(allRepos, repos...)
+		}
+
+		// Fan out issue fetching across repos.
+		var mu sync.Mutex
+		sem := make(chan struct{}, c.maxConcurrent)
+		var wg sync.WaitGroup
+		var firstErr error
+
+		for _, repo := range allRepos {
+			wg.Add(1)
+			go func(r Repo) {
+				defer wg.Done()
+				sem <- struct{}{}
+				defer func() { <-sem }()
+
+				path := fmt.Sprintf("/repos/%s/issues?state=%s&type=issues&limit=50", r.FullName, state)
+				resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
+				if err != nil {
+					mu.Lock()
+					if firstErr == nil {
+						firstErr = fmt.Errorf("fetching issues for %s: %w", r.FullName, err)
+					}
+					mu.Unlock()
+					return
 				}
-				mu.Unlock()
+				defer resp.Body.Close()
-				return
-			}
-			defer resp.Body.Close()
 
-			var prs []PullRequest
+				var issues []Issue
-			if err := json.NewDecoder(resp.Body).Decode(&prs); err != nil {
+				if err := json.NewDecoder(resp.Body).Decode(&issues); err != nil {
-				mu.Lock()
+					mu.Lock()
-				if firstErr == nil {
+					if firstErr == nil {
-					firstErr = fmt.Errorf("decoding PRs for %s: %w", r.FullName, err)
+						firstErr = fmt.Errorf("decoding issues for %s: %w", r.FullName, err)
+					}
+					mu.Unlock()
+					return
 				}
+
+				// Tag each issue with repo info.
+				for i := range issues {
+					issues[i].RepoOwner = r.Owner.Login
+					issues[i].RepoName = r.Name
+				}
+
+				mu.Lock()
+				allIssues = append(allIssues, issues...)
 				mu.Unlock()
-				return
+			}(repo)
-			}
+		}
 
-			for i := range prs {
+		wg.Wait()
-				prs[i].RepoOwner = r.Owner.Login
-				prs[i].RepoName = r.Name
-			}
 
-			mu.Lock()
+		if firstErr != nil {
-			allPRs = append(allPRs, prs...)
+			return PaginatedIssues{}, firstErr
-			mu.Unlock()
+		}
-		}(repo)
+
+		// Sort by updated time, newest first.
+		sort.Slice(allIssues, func(i, j int) bool {
+			return allIssues[i].UpdatedAt.After(allIssues[j].UpdatedAt)
+		})
+
+		c.setCache(cacheKey, allIssues)
 	}
 
-	wg.Wait()
+	// Paginate.
-
+	start := (page - 1) * PageSize
-	if firstErr != nil {
+	if start >= len(allIssues) {
-		return nil, firstErr
+		return PaginatedIssues{}, nil
+	}
+	end := start + PageSize
+	hasMore := end < len(allIssues)
+	if end > len(allIssues) {
+		end = len(allIssues)
 	}
 
-	sort.Slice(allPRs, func(i, j int) bool {
+	return PaginatedIssues{Issues: allIssues[start:end], HasMore: hasMore}, nil
-		return allPRs[i].UpdatedAt.After(allPRs[j].UpdatedAt)
+}
-	})
 
-	c.setCache(cacheKey, allPRs)
+// ListAllPullRequests fetches PRs across all repos in the given orgs.
-	return allPRs, nil
+// Results are paginated.
+func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []string, state string, page int) (PaginatedPulls, error) {
+	if state == "" {
+		state = "open"
+	}
+	if page < 1 {
+		page = 1
+	}
+
+	cacheKey := fmt.Sprintf("pulls-%s-%s", state, strings.Join(orgs, ","))
+	var allPRs []PullRequest
+	if cached, ok := c.getFromCache(cacheKey); ok {
+		allPRs = cached.([]PullRequest)
+	} else {
+		var allRepos []Repo
+		for _, org := range orgs {
+			repos, err := c.ListOrgRepos(ctx, token, org)
+			if err != nil {
+				return PaginatedPulls{}, fmt.Errorf("listing repos for %s: %w", org, err)
+			}
+			allRepos = append(allRepos, repos...)
+		}
+
+		var mu sync.Mutex
+		sem := make(chan struct{}, c.maxConcurrent)
+		var wg sync.WaitGroup
+		var firstErr error
+
+		for _, repo := range allRepos {
+			wg.Add(1)
+			go func(r Repo) {
+				defer wg.Done()
+				sem <- struct{}{}
+				defer func() { <-sem }()
+
+				path := fmt.Sprintf("/repos/%s/pulls?state=%s&limit=50", r.FullName, state)
+				resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
+				if err != nil {
+					mu.Lock()
+					if firstErr == nil {
+						firstErr = fmt.Errorf("fetching PRs for %s: %w", r.FullName, err)
+					}
+					mu.Unlock()
+					return
+				}
+				defer resp.Body.Close()
+
+				var prs []PullRequest
+				if err := json.NewDecoder(resp.Body).Decode(&prs); err != nil {
+					mu.Lock()
+					if firstErr == nil {
+						firstErr = fmt.Errorf("decoding PRs for %s: %w", r.FullName, err)
+					}
+					mu.Unlock()
+					return
+				}
+
+				for i := range prs {
+					prs[i].RepoOwner = r.Owner.Login
+					prs[i].RepoName = r.Name
+				}
+
+				mu.Lock()
+				allPRs = append(allPRs, prs...)
+				mu.Unlock()
+			}(repo)
+		}
+
+		wg.Wait()
+
+		if firstErr != nil {
+			return PaginatedPulls{}, firstErr
+		}
+
+		sort.Slice(allPRs, func(i, j int) bool {
+			return allPRs[i].UpdatedAt.After(allPRs[j].UpdatedAt)
+		})
+
+		c.setCache(cacheKey, allPRs)
+	}
+
+	// Paginate.
+	start := (page - 1) * PageSize
+	if start >= len(allPRs) {
+		return PaginatedPulls{}, nil
+	}
+	end := start + PageSize
+	hasMore := end < len(allPRs)
+	if end > len(allPRs) {
+		end = len(allPRs)
+	}
+
+	return PaginatedPulls{Pulls: allPRs[start:end], HasMore: hasMore}, nil
 }
 
 // GetTriageQueue returns unassigned issues and PRs needing review, sorted by priority.
 func (c *Client) GetTriageQueue(ctx context.Context, token string, orgs []string) ([]TriageItem, error) {
-	issues, err := c.ListAllIssues(ctx, token, orgs)
+	// Collect all open issues across all pages.
-	if err != nil {
+	var issues []Issue
-		return nil, fmt.Errorf("fetching issues for triage: %w", err)
+	for page := 1; ; page++ {
+		result, err := c.ListAllIssues(ctx, token, orgs, "open", page)
+		if err != nil {
+			return nil, fmt.Errorf("fetching issues for triage: %w", err)
+		}
+		issues = append(issues, result.Issues...)
+		if !result.HasMore {
+			break
+		}
 	}
 
-	prs, err := c.ListAllPullRequests(ctx, token, orgs)
+	// Collect all open PRs across all pages.
-	if err != nil {
+	var prs []PullRequest
-		return nil, fmt.Errorf("fetching PRs for triage: %w", err)
+	for page := 1; ; page++ {
+		result, err := c.ListAllPullRequests(ctx, token, orgs, "open", page)
+		if err != nil {
+			return nil, fmt.Errorf("fetching PRs for triage: %w", err)
+		}
+		prs = append(prs, result.Pulls...)
+		if !result.HasMore {
+			break
+		}
 	}
 
 	var queue []TriageItem

internal/handlers/handlers.go

@@ -245,6 +245,10 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 	if selectedState == "" {
 		selectedState = "open"
 	}
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	if page < 1 {
+		page = 1
+	}
 
 	data := issuesData{
 		Orgs:          orgNames,
@@ -261,15 +265,38 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 			queryOrgs = []string{selectedOrg}
 		}
 
-		issues, err := h.Client.ListAllIssues(r.Context(), token, queryOrgs)
+		result, err := h.Client.ListAllIssues(r.Context(), token, queryOrgs, selectedState, page)
 		if err != nil {
 			slog.Error("failed to list issues", "error", err)
 			data.Error = "Error loading issues."
 		} else {
-			data.Issues = issues
+			data.Issues = result.Issues
+			data.HasMore = result.HasMore
+			if result.HasMore {
+				data.NextPage = page + 1
+			}
 		}
 	}
 
+	// For HTMX infinite-scroll requests (page > 1), return only the card fragment.
+	if isHTMX(r) && page > 1 {
+		tmpl, err := template.ParseFiles("internal/templates/issues.html")
+		if err != nil {
+			slog.Error("failed to parse issues template", "error", err)
+			http.Error(w, "template error", http.StatusInternalServerError)
+			return
+		}
+		var buf strings.Builder
+		if err := tmpl.ExecuteTemplate(&buf, "cards", data); err != nil {
+			slog.Error("failed to execute issues cards template", "error", err)
+			http.Error(w, "template error", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		fmt.Fprint(w, buf.String())
+		return
+	}
+
 	tmpl, err := template.ParseFiles("internal/templates/issues.html")
 	if err != nil {
 		slog.Error("failed to parse issues template", "error", err)
@@ -296,10 +323,16 @@ func (h *Handler) ListPulls(w http.ResponseWriter, r *http.Request) {
 		Pulls       []giteaclient.PullRequest
 		Orgs        []string
 		SelectedOrg string
+		HasMore     bool
+		NextPage    int
 		Error       string
 	}
 
 	selectedOrg := r.URL.Query().Get("org")
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	if page < 1 {
+		page = 1
+	}
 
 	data := pullsData{
 		Orgs:        orgNames,
@@ -314,15 +347,38 @@ func (h *Handler) ListPulls(w http.ResponseWriter, r *http.Request) {
 			queryOrgs = []string{selectedOrg}
 		}
 
-		prs, err := h.Client.ListAllPullRequests(r.Context(), token, queryOrgs)
+		result, err := h.Client.ListAllPullRequests(r.Context(), token, queryOrgs, "open", page)
 		if err != nil {
 			slog.Error("failed to list pull requests", "error", err)
 			data.Error = "Error loading pull requests."
 		} else {
-			data.Pulls = prs
+			data.Pulls = result.Pulls
+			data.HasMore = result.HasMore
+			if result.HasMore {
+				data.NextPage = page + 1
+			}
 		}
 	}
 
+	// For HTMX infinite-scroll requests (page > 1), return only the card fragment.
+	if isHTMX(r) && page > 1 {
+		tmpl, err := template.ParseFiles("internal/templates/pulls.html")
+		if err != nil {
+			slog.Error("failed to parse pulls template", "error", err)
+			http.Error(w, "template error", http.StatusInternalServerError)
+			return
+		}
+		var buf strings.Builder
+		if err := tmpl.ExecuteTemplate(&buf, "cards", data); err != nil {
+			slog.Error("failed to execute pulls cards template", "error", err)
+			http.Error(w, "template error", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		fmt.Fprint(w, buf.String())
+		return
+	}
+
 	tmpl, err := template.ParseFiles("internal/templates/pulls.html")
 	if err != nil {
 		slog.Error("failed to parse pulls template", "error", err)

internal/templates/issues.html

@@ -1,3 +1,25 @@
+{{define "cards"}}
+  {{range .Issues}}
+  <div class="card" hx-get="/issues/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
+    <div class="card-title">{{.Title}}</div>
+    <div class="card-meta">
+      <span>{{.RepoOwner}}/{{.RepoName}} #{{.Number}}</span>
+      {{range .Labels}}
+      <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
+      {{end}}
+      {{if .Assignee}}
+      <span>{{.Assignee.Login}}</span>
+      {{end}}
+    </div>
+  </div>
+  {{end}}
+  {{if .HasMore}}
+  <div class="scroll-sentinel" hx-get="/issues?page={{.NextPage}}&org={{.SelectedOrg}}&state={{.SelectedState}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
+    <div class="spinner htmx-indicator"></div>
+  </div>
+  {{end}}
+{{end}}
+
 {{define "content"}}
 <h1>Issues</h1>
 
@@ -20,25 +42,7 @@
 <p class="empty">No issues found.</p>
 {{else}}
 <div id="issue-list">
-  {{range .Issues}}
+  {{template "cards" .}}
-  <div class="card" hx-get="/issues/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
-    <div class="card-title">{{.Title}}</div>
-    <div class="card-meta">
-      <span>{{.RepoOwner}}/{{.RepoName}} #{{.Number}}</span>
-      {{range .Labels}}
-      <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
-      {{end}}
-      {{if .Assignee}}
-      <span>{{.Assignee.Login}}</span>
-      {{end}}
-    </div>
-  </div>
-  {{end}}
-  {{if .HasMore}}
-  <div class="scroll-sentinel" hx-get="/issues?page={{.NextPage}}&org={{.SelectedOrg}}&state={{.SelectedState}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
-    <div class="spinner htmx-indicator"></div>
-  </div>
-  {{end}}
 </div>
 {{end}}
 {{end}}

internal/templates/pulls.html

@@ -1,3 +1,28 @@
+{{define "cards"}}
+  {{range .Pulls}}
+  <div class="card" hx-get="/pulls/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
+    <div class="card-title">
+      <span class="type-badge type-pull">PR</span>
+      {{.Title}}
+    </div>
+    <div class="card-meta">
+      <span>{{.RepoOwner}}/{{.RepoName}} #{{.Number}}</span>
+      {{range .Labels}}
+      <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
+      {{end}}
+      <span class="diff-add">+{{.Additions}}</span>
+      <span class="diff-del">-{{.Deletions}}</span>
+      {{if .Mergeable}}<span style="color:var(--accent-green);font-size:0.7rem;">mergeable</span>{{end}}
+    </div>
+  </div>
+  {{end}}
+  {{if .HasMore}}
+  <div class="scroll-sentinel" hx-get="/pulls?page={{.NextPage}}&org={{.SelectedOrg}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
+    <div class="spinner htmx-indicator"></div>
+  </div>
+  {{end}}
+{{end}}
+
 {{define "content"}}
 <h1>Pull Requests</h1>
 
@@ -16,23 +41,7 @@
 <p class="empty">No open pull requests found.</p>
 {{else}}
 <div id="pull-list">
-  {{range .Pulls}}
+  {{template "cards" .}}
-  <div class="card" hx-get="/pulls/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
-    <div class="card-title">
-      <span class="type-badge type-pull">PR</span>
-      {{.Title}}
-    </div>
-    <div class="card-meta">
-      <span>{{.RepoOwner}}/{{.RepoName}} #{{.Number}}</span>
-      {{range .Labels}}
-      <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
-      {{end}}
-      <span class="diff-add">+{{.Additions}}</span>
-      <span class="diff-del">-{{.Deletions}}</span>
-      {{if .Mergeable}}<span style="color:var(--accent-green);font-size:0.7rem;">mergeable</span>{{end}}
-    </div>
-  </div>
-  {{end}}
 </div>
 {{end}}
 {{end}}