appview: repo/issues: paginate issues

loading up issues on @tangled.sh/core should be much faster because we
only have to resolve ~10 DIDs at a time. with a saturated did-handle
cache, this should be near-instant page load times.

appview/db/issues.go

···
 	"time"
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
+	"tangled.sh/tangled.sh/core/appview/pagination"
 )
 
 type Issue struct {
···
 	return ownerDid, err
 }
 
-func GetIssues(e Execer, repoAt syntax.ATURI, isOpen bool) ([]Issue, error) {
+func GetIssues(e Execer, repoAt syntax.ATURI, isOpen bool, page pagination.Page) ([]Issue, error) {
 	var issues []Issue
 	openValue := 0
 	if isOpen {
···
 	}
 
 	rows, err := e.Query(
-		`select
-			i.owner_did,
-			i.issue_id,
-			i.created,
-			i.title,
-			i.body,
-			i.open,
-			count(c.id)
-		from
-		    issues i
-		left join
-			comments c on i.repo_at = c.repo_at and i.issue_id = c.issue_id
-		where
-		    i.repo_at = ? and i.open = ?
-		group by
-			i.id, i.owner_did, i.issue_id, i.created, i.title, i.body, i.open
-		order by
-			i.created desc`,
-		repoAt, openValue)
+		`
+		with numbered_issue as (
+			select
+				i.owner_did,
+				i.issue_id,
+				i.created,
+				i.title,
+				i.body,
+				i.open,
+				count(c.id) as comment_count,
+				row_number() over (order by i.created desc) as row_num
+			from
+				issues i
+			left join
+				comments c on i.repo_at = c.repo_at and i.issue_id = c.issue_id
+			where
+				i.repo_at = ? and i.open = ?
+			group by
+				i.id, i.owner_did, i.issue_id, i.created, i.title, i.body, i.open
+		)
+		select
+			owner_did,
+			issue_id,
+			created,
+			title,
+			body,
+			open,
+			comment_count
+		from 
+			numbered_issue
+		where 
+			row_num between ? and ?`,
+		repoAt, openValue, page.Offset+1, page.Offset+page.Limit)
 	if err != nil {
 		return nil, err
 	}

appview/middleware/middleware.go

···
 package middleware
 
 import (
+	"context"
 	"log"
 	"net/http"
+	"strconv"
 	"time"
 
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/xrpc"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/auth"
+	"tangled.sh/tangled.sh/core/appview/pagination"
 )
 
 type Middleware func(http.Handler) http.Handler
···
 			next.ServeHTTP(w, r)
 		})
 	}
+}
+
+func Paginate(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		page := pagination.FirstPage()
+
+		offsetVal := r.URL.Query().Get("offset")
+		if offsetVal != "" {
+			offset, err := strconv.Atoi(offsetVal)
+			if err != nil {
+				log.Println("invalid offset")
+			} else {
+				page.Offset = offset
+			}
+		}
+
+		limitVal := r.URL.Query().Get("limit")
+		if limitVal != "" {
+			limit, err := strconv.Atoi(limitVal)
+			if err != nil {
+				log.Println("invalid limit")
+			} else {
+				page.Limit = limit
+			}
+		}
+
+		ctx := context.WithValue(r.Context(), "page", page)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
 }

appview/pages/pages.go

···
 	"tangled.sh/tangled.sh/core/appview/auth"
 	"tangled.sh/tangled.sh/core/appview/db"
 	"tangled.sh/tangled.sh/core/appview/pages/markup"
+	"tangled.sh/tangled.sh/core/appview/pagination"
 	"tangled.sh/tangled.sh/core/appview/state/userutil"
 	"tangled.sh/tangled.sh/core/patchutil"
 	"tangled.sh/tangled.sh/core/types"
···
 }
 
 type RepoIssuesParams struct {
-	LoggedInUser *auth.User
-	RepoInfo     RepoInfo
-	Active       string
-	Issues       []db.Issue
-	DidHandleMap map[string]string
-
+	LoggedInUser    *auth.User
+	RepoInfo        RepoInfo
+	Active          string
+	Issues          []db.Issue
+	DidHandleMap    map[string]string
+	Page            pagination.Page
 	FilteringByOpen bool
 }
 

appview/pages/templates/repo/issues/issues.html

···
   </div>
   {{ end }}
 </div>
+
+{{ block "pagination" . }} {{ end }}
+
+{{ end }}
+
+{{ define "pagination" }}
+<div class="flex justify-end mt-4 gap-2">
+    {{ $currentState := "closed" }}
+    {{ if .FilteringByOpen }}
+      {{ $currentState = "open" }}
+    {{ end }}
+
+    {{ if gt .Page.Offset 0 }}
+       {{ $prev := .Page.Previous }}
+        <a
+            class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"
+            hx-boost="true"
+            href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&offset={{ $prev.Offset }}&limit={{ $prev.Limit }}"
+        >
+            {{ i "chevron-left" "w-4 h-4" }}
+            previous
+        </a>
+    {{ else }}
+        <div></div>
+    {{ end }}
+
+    {{ if eq (len .Issues) .Page.Limit }}
+       {{ $next := .Page.Next }}
+        <a
+            class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"
+            hx-boost="true"
+            href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&offset={{ $next.Offset }}&limit={{ $next.Limit }}"
+        >
+            next
+            {{ i "chevron-right" "w-4 h-4" }}
+        </a>
+    {{ end }}
+</div>
 {{ end }}

appview/pagination/page.go

···
+package pagination
+
+type Page struct {
+	Offset int // where to start from
+	Limit  int // number of items in a page
+}
+
+func FirstPage() Page {
+	return Page{
+		Offset: 0,
+		Limit:  10,
+	}
+}
+
+func (p Page) Previous() Page {
+	if p.Offset-p.Limit < 0 {
+		return FirstPage()
+	} else {
+		return Page{
+			Offset: p.Offset - p.Limit,
+			Limit:  p.Limit,
+		}
+	}
+}
+
+func (p Page) Next() Page {
+	return Page{
+		Offset: p.Offset + p.Limit,
+		Limit:  p.Limit,
+	}
+}

appview/state/repo.go

···
 	"tangled.sh/tangled.sh/core/appview/db"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/appview/pages/markup"
+	"tangled.sh/tangled.sh/core/appview/pagination"
 	"tangled.sh/tangled.sh/core/types"
 
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
···
 		isOpen = true
 	}
 
+	page, ok := r.Context().Value("page").(pagination.Page)
+	if !ok {
+		log.Println("failed to get page")
+		page = pagination.FirstPage()
+	}
+
 	user := s.auth.GetUser(r)
 	f, err := fullyResolvedRepo(r)
 	if err != nil {
···
 		return
 	}
 
-	issues, err := db.GetIssues(s.db, f.RepoAt, isOpen)
+	issues, err := db.GetIssues(s.db, f.RepoAt, isOpen, page)
 	if err != nil {
 		log.Println("failed to get issues", err)
 		s.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
 		Issues:          issues,
 		DidHandleMap:    didHandleMap,
 		FilteringByOpen: isOpen,
+		Page:            page,
 	})
 	return
 }

appview/state/router.go

···
 			r.Get("/blob/{ref}/raw/*", s.RepoBlobRaw)
 
 			r.Route("/issues", func(r chi.Router) {
-				r.Get("/", s.RepoIssues)
+				r.With(middleware.Paginate).Get("/", s.RepoIssues)
 				r.Get("/{issue}", s.RepoSingleIssue)
 
 				r.Group(func(r chi.Router) {