@zapier/zapier-sdk-cli 0.0.1

package/src/utils/pager.ts

@@ -0,0 +1,202 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+
+export interface PagerOptions {
+  pageSize?: number;
+  showPrompt?: boolean;
+  itemName?: string;
+}
+
+export interface PaginatedResult<T> {
+  items: T[];
+  hasMore: boolean;
+  totalShown: number;
+}
+
+/**
+ * Generic pager that handles pagination for any data source
+ * Supports interactive "load more" functionality
+ */
+export class Pager<T> {
+  private pageSize: number;
+  private showPrompt: boolean;
+  private itemName: string;
+  private allItems: T[] = [];
+  private currentOffset = 0;
+
+  constructor(options: PagerOptions = {}) {
+    this.pageSize = options.pageSize || 20;
+    this.showPrompt = options.showPrompt !== false;
+    this.itemName = options.itemName || "items";
+  }
+
+  /**
+   * Fetch and display paginated results with interactive loading
+   */
+  async paginate<TParams>(
+    fetchFunction: (
+      params: TParams & { limit: number; offset?: number },
+    ) => Promise<T[]>,
+    baseParams: TParams,
+    displayFunction: (
+      items: T[],
+      totalShown: number,
+      totalAvailable?: number,
+    ) => void,
+  ): Promise<PaginatedResult<T>> {
+    let hasMore = true;
+    let totalAvailable: number | undefined;
+
+    while (hasMore) {
+      // Fetch next page
+      const params = {
+        ...baseParams,
+        limit: this.pageSize,
+        offset: this.currentOffset,
+      };
+
+      try {
+        const items = await fetchFunction(params);
+
+        if (items.length === 0) {
+          // Still call display function to show "No items found" message
+          displayFunction(this.allItems, this.allItems.length, totalAvailable);
+          hasMore = false;
+          break;
+        }
+
+        // Check for pagination metadata to get total count
+        const pagination = (items as any).__pagination;
+        if (pagination && pagination.count) {
+          totalAvailable = pagination.count;
+          hasMore = pagination.hasNext;
+        } else {
+          // Fallback: check if we got fewer items than requested
+          hasMore = items.length >= this.pageSize;
+        }
+
+        // Add to our collection
+        this.allItems.push(...items);
+        this.currentOffset += items.length;
+
+        // Display current batch
+        displayFunction(this.allItems, this.allItems.length, totalAvailable);
+
+        // If prompting is disabled, continue automatically
+        if (!this.showPrompt) {
+          continue;
+        }
+
+        // If we have total count info, show more detailed prompt
+        const totalInfo = totalAvailable
+          ? ` of ${totalAvailable.toLocaleString()}`
+          : "";
+        const message = `Load more ${this.itemName}? (${this.allItems.length}${totalInfo} shown so far)`;
+
+        // Ask user if they want to load more
+        const { loadMore } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "loadMore",
+            message,
+            default: true,
+          },
+        ]);
+
+        if (!loadMore) {
+          hasMore = false;
+        }
+      } catch (error) {
+        // Re-throw the error to be handled by the caller
+        throw error;
+      }
+    }
+
+    return {
+      items: this.allItems,
+      hasMore: this.currentOffset > 0 && hasMore,
+      totalShown: this.allItems.length,
+    };
+  }
+
+  /**
+   * Reset the pager state
+   */
+  reset(): void {
+    this.allItems = [];
+    this.currentOffset = 0;
+  }
+}
+
+/**
+ * Convenience function to create a pager for a specific use case
+ */
+export function createPager<T>(options: PagerOptions = {}): Pager<T> {
+  return new Pager<T>(options);
+}
+
+/**
+ * Simple pagination without interactivity - just fetches all results up to a limit
+ */
+export async function fetchAllPages<T, TParams>(
+  fetchFunction: (
+    params: TParams & { limit: number; offset?: number },
+  ) => Promise<T[]>,
+  baseParams: TParams,
+  maxResults: number = 100,
+): Promise<T[]> {
+  const pageSize = Math.min(maxResults, 50); // Reasonable page size
+  const allItems: T[] = [];
+  let offset = 0;
+
+  while (allItems.length < maxResults) {
+    const remainingItems = maxResults - allItems.length;
+    const currentPageSize = Math.min(pageSize, remainingItems);
+
+    const params = {
+      ...baseParams,
+      limit: currentPageSize,
+      offset,
+    };
+
+    const items = await fetchFunction(params);
+
+    if (items.length === 0) {
+      break; // No more data
+    }
+
+    allItems.push(...items);
+    offset += items.length;
+
+    // If we got fewer items than requested, we've reached the end
+    if (items.length < currentPageSize) {
+      break;
+    }
+  }
+
+  return allItems;
+}
+
+/**
+ * Display helper for showing pagination status
+ */
+export function showPaginationStatus(
+  currentCount: number,
+  requestedLimit: number,
+  itemName: string = "items",
+): void {
+  if (currentCount >= requestedLimit) {
+    console.log(
+      chalk.yellow(
+        `\n📄 Showing first ${currentCount} ${itemName} (limit: ${requestedLimit})`,
+      ),
+    );
+    console.log(
+      chalk.gray(
+        `Use --limit to increase the limit, or add paging with --page`,
+      ),
+    );
+  } else {
+    console.log(chalk.gray(`\n📄 Showing all ${currentCount} ${itemName}`));
+  }
+}