Jobs list pagination treated every full page as if another page existed. Exact multiples of the page size could enable Next on the final page, and inclusive cursor bounds could repeat the boundary job when paging back or in ascending order.

Normalize cursor-boundary duplicates before rendering a page and probe for one more page only when a page is completely full. The dashboard now disables Next when no later page exists while keeping page boundaries stable across forward and backward navigation.

Author: thomashoneyman

dashboard/src/Dashboard/Component/JobsList.purs

@@ -141,6 +141,11 @@ type State =
   , pageCursor :: Maybe PageCursor
   }
 
+type FetchResult =
+  { jobs :: Array Job
+  , hasNextPage :: Boolean
+  }
+
 -- | Direction of a pagination cursor relative to the sort order.
 data PaginationDir = Forward | Backward
 
@@ -168,7 +173,7 @@ data Action
   = Initialize
   | FetchJobs
   | FetchJobsSilent
-  | HandleFetchResult (Either ApiError (Array Job))
+  | HandleFetchResult (Either ApiError FetchResult)
   | SetTimeRange TimeRange
   | SetCustomSinceDate String
   | SetCustomSinceTime String
@@ -687,21 +692,16 @@ handleAction = case _ of
           else
             msg
       H.modify_ _ { loading = false, error = Just displayMsg, jobs = [] }
-    Right jobs -> do
+    Right { jobs, hasNextPage } -> do
       state <- H.get
       let summaries = map Job.toJobSummary jobs
       let newFingerprints = map jobFingerprint summaries
       let oldFingerprints = map jobFingerprint state.jobs
       -- Skip the state update when the set of jobs hasn't changed. This
       -- avoids VDOM diffing on every auto-refresh tick when nothing new
       -- has arrived.
-      unless (not state.loading && newFingerprints == oldFingerprints) do
-        let
-          isBackward = case state.pageCursor of
-            Just { dir: Backward } -> true
-            _ -> false
-        let hasNext = isBackward || Array.length jobs >= pageSize
-        H.modify_ _ { loading = false, error = Nothing, jobs = summaries, hasNextPage = hasNext }
+      unless (not state.loading && newFingerprints == oldFingerprints && state.hasNextPage == hasNextPage) do
+        H.modify_ _ { loading = false, error = Nothing, jobs = summaries, hasNextPage = hasNextPage }
 
   SetTimeRange range -> do
     when (range == Custom) do
@@ -773,11 +773,7 @@ handleAction = case _ of
   NextPage -> do
     state <- H.get
     when (state.hasNextPage && not state.loading) do
-      let
-        cursor = case state.sortOrder of
-          DESC -> extremeCreatedAt min state.jobs
-          ASC -> extremeCreatedAt max state.jobs
-      case cursor of
+      case nextPageCursor state.sortOrder state.jobs of
         Nothing -> pure unit
         Just ts -> do
           H.modify_ _ { currentPage = state.currentPage + 1, pageCursor = Just { timestamp: ts, dir: Forward } }
@@ -794,11 +790,7 @@ handleAction = case _ of
         handleAction FetchJobs
         notifyFiltersChanged
       else do
-        let
-          cursor = case state.sortOrder of
-            DESC -> extremeCreatedAt max state.jobs
-            ASC -> extremeCreatedAt min state.jobs
-        case cursor of
+        case prevPageCursor state.sortOrder state.jobs of
           Nothing -> pure unit
           Just ts -> do
             H.modify_ _ { currentPage = targetPage, pageCursor = Just { timestamp: ts, dir: Backward }, hasNextPage = true }
@@ -827,10 +819,27 @@ jobFingerprint job =
   }
 
 -- | Build query parameters from the current state and fetch jobs from the API.
-doFetchJobs :: forall m. MonadAff m => H.HalogenM State Action () Output m (Either ApiError (Array Job))
+doFetchJobs :: forall m. MonadAff m => H.HalogenM State Action () Output m (Either ApiError FetchResult)
 doFetchJobs = do
   state <- H.get
   now <- liftEffect Now.nowDateTime
+  jobsResult <- fetchJobsPage state now state.pageCursor
+  case jobsResult of
+    Left err ->
+      pure (Left err)
+    Right jobs -> do
+      hasNextPage <- determineHasNextPage state now jobs
+      pure (Right { jobs, hasNextPage })
+
+-- | Fetch one jobs page using the current filters and an optional pagination cursor.
+fetchJobsPage
+  :: forall m
+   . MonadAff m
+  => State
+  -> DateTime
+  -> Maybe PageCursor
+  -> H.HalogenM State Action () Output m (Either ApiError (Array Job))
+fetchJobsPage state now cursor = do
   let
     customSince = Job.parseDateTimeLocal state.sinceStr
     customUntil = Job.parseDateTimeLocal state.untilStr
@@ -842,7 +851,7 @@ doFetchJobs = do
       Custom -> customUntil
       UntilNow -> Just now
       _ -> Nothing
-    { since, until, fetchOrder, needsReverse } = case state.pageCursor of
+    { since, until, fetchOrder, needsReverse } = case cursor of
       Nothing ->
         { since: baseSince, until: baseUntil, fetchOrder: state.sortOrder, needsReverse: false }
       Just { timestamp, dir: Forward } -> case state.sortOrder of
@@ -853,7 +862,34 @@ doFetchJobs = do
         ASC -> { since: baseSince, until: Just timestamp, fetchOrder: DESC, needsReverse: true }
     includeCompleted = Just (state.filters.statusFilter /= ActiveOnly)
   result <- H.liftAff $ API.fetchJobs state.apiConfig { since, until, order: Just fetchOrder, includeCompleted }
-  pure $ if needsReverse then map Array.reverse result else result
+  pure $ map (normalizeFetchedJobs state.sortOrder cursor <<< applyFetchedOrder needsReverse) result
+
+-- | Decide whether another page exists past the current page. Full pages require
+-- | a probe request because the jobs API is capped at `pageSize`.
+determineHasNextPage
+  :: forall m
+   . MonadAff m
+  => State
+  -> DateTime
+  -> Array Job
+  -> H.HalogenM State Action () Output m Boolean
+determineHasNextPage state now jobs = do
+  let
+    isBackward = case state.pageCursor of
+      Just { dir: Backward } -> true
+      _ -> false
+  if isBackward then
+    pure true
+  else if Array.length jobs < pageSize then
+    pure false
+  else case nextPageCursorForJobs state.sortOrder jobs of
+    Nothing ->
+      pure false
+    Just ts -> do
+      probe <- fetchJobsPage state now (Just { timestamp: ts, dir: Forward })
+      pure case probe of
+        Left _ -> true
+        Right nextJobs -> not (Array.null nextJobs)
 
 -- | Update the combined sinceStr from a date or time part change, fetch if
 -- | both endpoints parse, and sync the URL.
@@ -897,14 +933,60 @@ syncAutoRefresh enabled = do
 refreshInterval :: Milliseconds
 refreshInterval = Milliseconds 5000.0
 
--- | Find the extreme (min or max) `createdAt` timestamp among job summaries.
-extremeCreatedAt :: (DateTime -> DateTime -> DateTime) -> Array JobSummary -> Maybe DateTime
-extremeCreatedAt pick = Array.foldl (\acc s -> Just (maybe s.createdAt (pick s.createdAt) acc)) Nothing
+-- | Find the extreme (min or max) `createdAt` timestamp using the provided accessor.
+extremeCreatedAtBy :: forall a. (a -> DateTime) -> (DateTime -> DateTime -> DateTime) -> Array a -> Maybe DateTime
+extremeCreatedAtBy getCreatedAt pick = Array.foldl (\acc row -> Just (maybe (getCreatedAt row) (pick (getCreatedAt row)) acc)) Nothing
   where
   maybe fallback f = case _ of
     Nothing -> fallback
     Just x -> f x
 
+nextPageCursor :: forall a. SortOrder -> Array { createdAt :: DateTime | a } -> Maybe DateTime
+nextPageCursor sortOrder jobs = case sortOrder of
+  DESC -> extremeCreatedAtBy _.createdAt min jobs
+  ASC -> extremeCreatedAtBy _.createdAt max jobs
+
+prevPageCursor :: forall a. SortOrder -> Array { createdAt :: DateTime | a } -> Maybe DateTime
+prevPageCursor sortOrder jobs = case sortOrder of
+  DESC -> extremeCreatedAtBy _.createdAt max jobs
+  ASC -> extremeCreatedAtBy _.createdAt min jobs
+
+nextPageCursorForJobs :: SortOrder -> Array Job -> Maybe DateTime
+nextPageCursorForJobs sortOrder jobs = case sortOrder of
+  DESC -> extremeCreatedAtBy (V1.jobInfo >>> _.createdAt) min jobs
+  ASC -> extremeCreatedAtBy (V1.jobInfo >>> _.createdAt) max jobs
+
+applyFetchedOrder :: Boolean -> Array Job -> Array Job
+applyFetchedOrder needsReverse =
+  if needsReverse then Array.reverse else identity
+
+normalizeFetchedJobs :: SortOrder -> Maybe PageCursor -> Array Job -> Array Job
+normalizeFetchedJobs sortOrder cursor jobs = case cursor of
+  Just { timestamp, dir: Forward }
+    | sortOrder == ASC ->
+        dropBoundaryFromStart timestamp jobs
+  Just { timestamp, dir: Backward }
+    | sortOrder == DESC ->
+        dropBoundaryFromEnd timestamp jobs
+  _ ->
+    jobs
+
+dropBoundaryFromStart :: DateTime -> Array Job -> Array Job
+dropBoundaryFromStart timestamp jobs = case Array.uncons jobs of
+  Just { head, tail }
+    | (V1.jobInfo head).createdAt == timestamp ->
+        tail
+  _ ->
+    jobs
+
+dropBoundaryFromEnd :: DateTime -> Array Job -> Array Job
+dropBoundaryFromEnd timestamp jobs = case Array.unsnoc jobs of
+  Just { init, last }
+    | (V1.jobInfo last).createdAt == timestamp ->
+        init
+  _ ->
+    jobs
+
 -- | Apply client-side filters to an array of job summaries.
 applyFilters :: Filters -> Array JobSummary -> Array JobSummary
 applyFilters filters = Array.filter matchesAll