Add events pagination updates

Author: ptrus

src/fetchEvents.js

@@ -296,7 +296,9 @@ export const fetchEvents = async (NEXUS_API, address, year, before, after, layer
     const { items: events, wasClipped: eventsClipped } = await paginatedFetch(
       `${NEXUS_API}/${layer}/events`,
       { after, before, rel: address },
-      "events"
+      "events",
+      1000,
+      (count, page) => setProgress(`Fetching events... (${count} items, page ${page})`)
     );
 
     if (eventsClipped) {
@@ -309,7 +311,9 @@ export const fetchEvents = async (NEXUS_API, address, year, before, after, layer
       const { items: txItems, wasClipped: txClipped } = await paginatedFetch(
         `${NEXUS_API}/${layer}/transactions`,
         { after, before, rel: address },
-        "transactions"
+        "transactions",
+        1000,
+        (count, page) => setProgress(`Fetching transactions... (${count} items, page ${page})`)
       );
       transactions = txItems;
 

src/utils.js

@@ -2,6 +2,29 @@ import axios from "axios";
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+/**
+ * Fetch with retry logic.
+ * @param {function} fetchFn - Async function to execute
+ * @param {number} maxRetries - Maximum number of retries (default 3)
+ * @param {number} baseDelay - Base delay in ms for exponential backoff (default 1000)
+ * @returns {Promise<*>} - Result of the fetch function
+ */
+const fetchWithRetry = async (fetchFn, maxRetries = 3, baseDelay = 1000) => {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fetchFn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxRetries) {
+        const delay = baseDelay * Math.pow(2, attempt);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+};
+
 /**
  * Paginated fetch helper that handles limit/offset pagination.
  * Stops when items.length < limit or offset >= total_count.
@@ -11,21 +34,25 @@ const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
  * @param {object} params - Query parameters (limit will be set automatically)
  * @param {string} itemsKey - The key in response.data containing the items array
  * @param {number} limit - Page size (default 1000)
+ * @param {function} onProgress - Optional callback for progress updates (called with items count)
  * @returns {Promise<{items: Array, wasClipped: boolean}>}
  */
-export const paginatedFetch = async (url, params, itemsKey, limit = 1000) => {
+export const paginatedFetch = async (url, params, itemsKey, limit = 1000, onProgress = null) => {
   let items = [];
   let offset = 0;
   let wasClipped = false;
+  let pageNum = 1;
 
   while (true) {
-    const response = await axios.get(url, {
-      params: {
-        ...params,
-        limit,
-        offset,
-      },
-    });
+    const response = await fetchWithRetry(() =>
+      axios.get(url, {
+        params: {
+          ...params,
+          limit,
+          offset,
+        },
+      })
+    );
 
     const pageItems = response.data[itemsKey] || [];
     items = [...items, ...pageItems];
@@ -35,6 +62,11 @@ export const paginatedFetch = async (url, params, itemsKey, limit = 1000) => {
       wasClipped = true;
     }
 
+    // Report progress if callback provided
+    if (onProgress) {
+      onProgress(items.length, pageNum);
+    }
+
     // Break if we got fewer than the limit (last page)
     // Note: When is_total_count_clipped is true, total_count is capped (often at 1000),
     // so we can't rely on offset >= total_count to know we're done.
@@ -44,6 +76,7 @@ export const paginatedFetch = async (url, params, itemsKey, limit = 1000) => {
     }
 
     offset += pageItems.length;
+    pageNum++;
     await sleep(100);
   }