@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

package/dist/utils/auto-pagination.d.ts

@@ -0,0 +1,549 @@
+/**
+ * Auto-Pagination Utility
+ *
+ * Generic utility for automatically paginating through API results.
+ * Supports multiple pagination strategies: page-based, offset-based, cursor-based, and bookmark-based.
+ * Eliminates duplicate pagination logic across multiple services.
+ *
+ * @packageDocumentation
+ */
+import type { PageInfo } from '../types/common';
+import type { Logger } from './Logger';
+/**
+ * Result object from paginated API calls
+ * Expected structure for services using this utility
+ */
+export interface PaginatedResult<T> {
+    /** Array of items returned from this page */
+    items: T[];
+    /** Current page number */
+    page: number;
+    /** Page size/limit for this request */
+    limit: number;
+    /** Total count of all items across all pages */
+    total: number;
+    /** Total number of pages available */
+    totalPages: number;
+    /** Whether there is a next page available */
+    hasNext: boolean;
+    /** Whether there is a previous page available */
+    hasPrevious: boolean;
+}
+/**
+ * Options for auto-pagination
+ */
+export interface AutoPaginationOptions {
+    /** Maximum number of pages to fetch (safety limit to prevent infinite loops) */
+    maxPages?: number;
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Page size to use for each request */
+    pageSize?: number;
+    /**
+     * Number of pages to fetch concurrently (default: 1 = sequential)
+     * Set to higher values (e.g., 5) to fetch multiple pages in parallel for better performance.
+     * Useful when total pages is unknown and you want to maximize throughput.
+     * @since 5.0.4
+     */
+    concurrency?: number;
+    /**
+     * Starting page number (default: 1)
+     * Use when you need to start pagination from a specific page.
+     * @since 5.0.4
+     */
+    startPage?: number;
+}
+/**
+ * Result object from auto-pagination
+ */
+export interface AutoPaginationResult<T> {
+    /** All items from all pages combined */
+    items: T[];
+    /** Total count from the API (across all pages) */
+    total: number;
+}
+/**
+ * Generic auto-pagination handler
+ *
+ * Automatically iterates through all pages of paginated API results
+ * and combines them into a single array. Handles common patterns like:
+ * - Safety limits to prevent infinite loops
+ * - Empty result detection
+ * - Debug logging of pagination progress
+ * - Preserves total count from the API
+ * - Concurrent fetching for high-throughput scenarios (optional)
+ *
+ * @typeParam T - Type of items being paginated
+ * @param fetchFn Function that fetches a single page of results
+ * @param options Pagination options (maxPages, logger, pageSize, concurrency, startPage)
+ * @returns Promise<AutoPaginationResult> All items and total count from the API
+ *
+ * @example Sequential pagination (default)
+ * ```typescript
+ * const result = await autoPaginate(
+ *   (page, limit) => service.fetchPools({ page, limit }),
+ *   { maxPages: 1000, pageSize: 20, logger }
+ * );
+ * console.log(`Total: ${result.total}, Fetched: ${result.items.length}`);
+ * ```
+ *
+ * @example Concurrent pagination (high throughput)
+ * ```typescript
+ * const result = await autoPaginate(
+ *   (page, limit) => service.fetchPools({ page, limit }),
+ *   { pageSize: 20, concurrency: 5, logger }  // Fetch 5 pages at a time
+ * );
+ * ```
+ *
+ * @example Start from specific page with limit
+ * ```typescript
+ * const result = await autoPaginate(
+ *   (page, limit) => service.fetchPools({ page, limit }),
+ *   { startPage: 3, maxPages: 5, pageSize: 20, concurrency: 5 }  // Pages 3-7
+ * );
+ * ```
+ *
+ * @since 3.32.0
+ * @since 5.0.4 - Added concurrency and startPage options
+ */
+export declare function autoPaginate<T>(fetchFn: (page: number, limit: number) => Promise<PaginatedResult<T>>, options?: AutoPaginationOptions): Promise<AutoPaginationResult<T>>;
+/**
+ * Result object from bookmark-based API calls
+ * Returned by fetchFn in autoPaginateWithBookmark
+ */
+export interface BookmarkPaginationResult<T> {
+    /** Array of items returned from this page */
+    items: T[];
+    /** Bookmark/cursor for fetching the next page
+     *  - undefined: field was not present in API response
+     *  - empty string "": API signals last page reached
+     *  - non-empty string: bookmark to use for next request
+     */
+    nextBookmark: string | undefined;
+}
+/**
+ * Options for bookmark-based auto-pagination
+ * Used for APIs that use cursor-based pagination (bookmarks) instead of page numbers
+ */
+export interface AutoPaginationWithBookmarkOptions {
+    /** Maximum number of pages to fetch (safety limit to prevent infinite loops) */
+    maxPages?: number;
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Page size to use for each request */
+    pageSize?: number;
+}
+/**
+ * Bookmark-based auto-pagination handler
+ *
+ * Automatically iterates through all pages of bookmark-based paginated API results
+ * (cursor-based pagination) and combines them into a single array.
+ *
+ * Used for APIs that return bookmarks/cursors instead of page numbers (e.g., GSwap positions API).
+ * Handles common patterns like:
+ * - Safety limits to prevent infinite loops
+ * - Empty result detection
+ * - Debug logging of pagination progress
+ * - Proper bookmark extraction from API responses
+ * - Dual completion detection (no nextBookmark OR fewer items than requested)
+ *
+ * @typeParam T - Type of items being paginated
+ * @param fetchFn Function that fetches a single page and returns items with optional nextBookmark.
+ *                Should return { items: T[], nextBookmark?: string }.
+ *                If bookmark is undefined, fetches first page.
+ * @param options Pagination options (maxPages, logger, pageSize)
+ * @returns Promise<AutoPaginationResult> All items combined from all pages
+ *
+ * @example Basic usage with bookmark-returning API
+ * ```typescript
+ * const result = await autoPaginateWithBookmark(
+ *   async (bookmark, pageSize) => {
+ *     const response = await api.getPositions({ bookmark, limit: pageSize });
+ *     return {
+ *       items: response.positions,
+ *       nextBookmark: response.metadata?.nextBookmark
+ *     };
+ *   },
+ *   { maxPages: 1000, pageSize: 10, logger }
+ * );
+ * console.log(`Total fetched: ${result.items.length}`);
+ * ```
+ *
+ * @example Legacy: Returns items array directly (uses item count for completion)
+ * ```typescript
+ * const result = await autoPaginateWithBookmark(
+ *   (bookmark, pageSize) => service.getPositions(walletAddress, pageSize, bookmark),
+ *   { maxPages: 1000, pageSize: 10, logger }
+ * );
+ * ```
+ *
+ * @since 3.32.0
+ * @since 3.33.0 - Enhanced to support true bookmark-based pagination with BookmarkPaginationResult<T>
+ */
+export declare function autoPaginateWithBookmark<T>(fetchFn: (bookmark: string | undefined, pageSize: number) => Promise<BookmarkPaginationResult<T> | T[]>, options?: AutoPaginationWithBookmarkOptions): Promise<AutoPaginationResult<T>>;
+/**
+ * Build paginated result object for returning combined auto-paginated data
+ *
+ * Helper function to construct the standard paginated result structure
+ * when returning combined results from auto-pagination. Supports custom item
+ * key naming for service-specific result structures (pools, snapshots, etc.).
+ *
+ * Eliminates 5-7 line response object construction patterns found in:
+ * - DexPoolService.fetchAllDexPools() (lines 209-219)
+ * - PriceHistoryService.fetchAllPriceHistory() (lines 433-442)
+ * - Other services with similar patterns
+ *
+ * @typeParam T - Type of items in the result
+ * @param items Combined array of all items from all pages
+ * @param total Total count from last page (or sum of counts)
+ * @param itemsKey Optional field name for items (default: 'items'). Use for service-specific naming like 'pools', 'snapshots'
+ * @returns PaginatedResult object with items flattened into a single "page"
+ *
+ * @example Basic usage (default 'items' key)
+ * ```typescript
+ * const allItems = await autoPaginate(fetchFn);
+ * return buildPaginatedResult(allItems.items, allItems.total);
+ * // Returns: { items, page: 1, limit, total, totalPages: 1, hasNext: false, hasPrevious: false }
+ * ```
+ *
+ * @example With custom items key (eliminates manual response construction)
+ * ```typescript
+ * // DexPoolService - before (7 lines)
+ * const result = buildPaginatedResult(paginationResult.items, paginationResult.total);
+ * return {
+ *   pools: result.items,
+ *   page: result.page,
+ *   limit: result.limit,
+ *   total: result.total,
+ *   totalPages: result.totalPages,
+ *   hasNext: result.hasNext,
+ *   hasPrevious: result.hasPrevious,
+ * };
+ *
+ * // DexPoolService - after (1 line)
+ * return buildPaginatedResult(paginationResult.items, paginationResult.total, 'pools');
+ * ```
+ *
+ * @example Other service patterns
+ * ```typescript
+ * // PriceHistoryService
+ * return buildPaginatedResult(paginationResult.items, paginationResult.total, 'snapshots');
+ * ```
+ *
+ * @since 3.32.0 - itemsKey parameter added in 3.32.0 for response structure flexibility
+ */
+export declare function buildPaginatedResult<T>(items: T[], total?: number, itemsKey?: 'items' | 'pools' | 'snapshots' | string): Record<string, unknown>;
+/**
+ * Options for offset-based auto-pagination
+ * Used for APIs that use offset/limit pagination instead of page numbers
+ */
+export interface AutoPaginationOffsetOptions {
+    /** Maximum items per request (limit) */
+    maxLimit: number;
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Maximum number of pages to fetch (safety limit) - defaults to 10000 */
+    maxPages?: number;
+}
+/**
+ * Result from offset-based pagination fetch function
+ * Generic structure to extract items from different API response shapes
+ */
+export interface OffsetPaginationFetchResult<TItem> {
+    /** Array of items from this page */
+    items: TItem[];
+    /** Count of raw items in response (for hasMore detection) */
+    rawCount: number;
+}
+/**
+ * Offset-based auto-pagination handler
+ *
+ * Automatically iterates through all pages of offset-based paginated API results
+ * and combines them into a single array. This is the variant for APIs that use
+ * offset/limit parameters instead of page numbers or bookmarks.
+ *
+ * Common pattern eliminated:
+ * ```typescript
+ * let offset = 0;
+ * let hasMore = true;
+ * while (hasMore) {
+ *   const response = await api.request({ offset, limit: MAX_LIMIT });
+ *   items.push(...transform(response));
+ *   hasMore = response.length === MAX_LIMIT;
+ *   offset += MAX_LIMIT;
+ * }
+ * ```
+ *
+ * @typeParam TItem - Type of items being paginated (after transformation)
+ * @param fetchFn - Function that fetches a single page given offset and limit.
+ *                  Returns { items: transformed items, rawCount: raw API response count }
+ * @param options - Pagination options (maxLimit, logger, maxPages)
+ * @returns Promise resolving to array of all items
+ *
+ * @example Basic usage
+ * ```typescript
+ * const allTokens = await autoPaginateOffset(
+ *   async (offset, limit) => {
+ *     const response = await api.request({ offset, limit });
+ *     return {
+ *       items: transformTokens(response.tokens),
+ *       rawCount: response.tokens.length
+ *     };
+ *   },
+ *   { maxLimit: 1000, logger }
+ * );
+ * ```
+ *
+ * @since 5.0.2
+ */
+export declare function autoPaginateOffset<TItem>(fetchFn: (offset: number, limit: number) => Promise<OffsetPaginationFetchResult<TItem>>, options: AutoPaginationOffsetOptions): Promise<TItem[]>;
+/**
+ * Cache interface for fetchAllWithCache helper
+ *
+ * Defines the minimal cache API required by the fetchAllWithCache utility.
+ * Allows different cache implementations (BridgeableTokenCache, WrappableTokenCache)
+ * to be used with the same helper function.
+ *
+ * @typeParam T - Type of items stored in the cache
+ * @since 5.10.0
+ */
+export interface CacheInterface<T> {
+    /** Check if cache has data */
+    has(): boolean;
+    /** Get all cached items */
+    getAll(): T[];
+    /** Get fetch timestamp (when cache was last populated) */
+    getFetchTimestamp(): number | null | undefined;
+    /** Set/replace cache with new items */
+    setAll(items: T[]): void;
+}
+/**
+ * Cache interface for network-keyed caches (like BridgeableTokenCache)
+ *
+ * Extended interface for caches that store items per-network key.
+ *
+ * @typeParam T - Type of items stored in the cache
+ * @typeParam K - Network key type (e.g., BridgeableNetwork)
+ * @since 5.10.0
+ */
+export interface NetworkCacheInterface<T, K extends string = string> {
+    /** Check if cache has data for a network */
+    has(network: K): boolean;
+    /** Get all cached items for a network */
+    getAll(network: K): T[];
+    /** Get fetch timestamp for a network */
+    getFetchTimestamp(network: K): number | null | undefined;
+    /** Set/replace cache for a network */
+    set(network: K, items: T[]): void;
+}
+/**
+ * Options for fetchAllWithCache helper
+ */
+export interface FetchAllWithCacheOptions<T> {
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Function to fetch all items (already paginated) */
+    fetchFn: () => Promise<T[]>;
+    /** Cache instance implementing CacheInterface */
+    cache: CacheInterface<T>;
+    /** Item type name for logging (e.g., 'wrappable tokens') */
+    itemTypeName?: string;
+}
+/**
+ * Options for fetchAllWithNetworkCache helper
+ */
+export interface FetchAllWithNetworkCacheOptions<T, K extends string = string> {
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Network key to fetch/cache for */
+    network: K;
+    /** Function to fetch all items for the network (already paginated) */
+    fetchFn: () => Promise<T[]>;
+    /** Cache instance implementing NetworkCacheInterface */
+    cache: NetworkCacheInterface<T, K>;
+    /** Item type name for logging (e.g., 'bridgeable tokens') */
+    itemTypeName?: string;
+}
+/**
+ * Result structure for fetchAllWithCache helpers
+ *
+ * Standard return format with items, timestamp, and count.
+ */
+export interface FetchAllWithCacheResult<T> {
+    /** All fetched or cached items */
+    items: T[];
+    /** Timestamp when data was fetched (epoch ms) */
+    fetchedAt: number;
+    /** Number of items */
+    itemCount: number;
+}
+/**
+ * Fetch all items with caching support (simple cache)
+ *
+ * Helper that eliminates the repetitive cache-check -> fetch -> cache-store pattern
+ * found in services like WrappableTokenService.fetchAllWrappableTokens().
+ *
+ * Common pattern eliminated:
+ * ```typescript
+ * if (this.cache.has()) {
+ *   const items = this.cache.getAll();
+ *   return { items, fetchedAt: this.cache.getFetchTimestamp(), itemCount: items.length };
+ * }
+ * const allItems = await autoPaginateOffset(...);
+ * this.cache.setAll(allItems);
+ * return { items: allItems, fetchedAt: Date.now(), itemCount: allItems.length };
+ * ```
+ *
+ * @typeParam T - Type of items being fetched
+ * @param options - Options including cache, fetchFn, and logger
+ * @returns Promise resolving to items with fetchedAt timestamp and count
+ *
+ * @example Basic usage
+ * ```typescript
+ * const result = await fetchAllWithCache({
+ *   cache: this.cache,
+ *   fetchFn: () => autoPaginateOffset(
+ *     async (offset, limit) => ({
+ *       items: this.transformTokens(response.tokens),
+ *       rawCount: response.tokens.length,
+ *     }),
+ *     { maxLimit: MAX_LIMIT, logger: this.logger }
+ *   ),
+ *   logger: this.logger,
+ *   itemTypeName: 'wrappable tokens',
+ * });
+ * ```
+ *
+ * @since 5.10.0
+ */
+export declare function fetchAllWithCache<T>(options: FetchAllWithCacheOptions<T>): Promise<FetchAllWithCacheResult<T>>;
+/**
+ * Fetch all items with network-keyed caching support
+ *
+ * Helper that eliminates the repetitive cache-check -> fetch -> cache-store pattern
+ * found in services like BridgeableTokenService.fetchAllBridgeableTokensByNetwork().
+ *
+ * Common pattern eliminated:
+ * ```typescript
+ * if (this.cache.has(network)) {
+ *   const tokens = this.cache.getAll(network);
+ *   return { tokens, network, fetchedAt: this.cache.getFetchTimestamp(network), tokenCount: tokens.length };
+ * }
+ * const allTokens = await autoPaginateOffset(...);
+ * this.cache.set(network, allTokens);
+ * return { tokens: allTokens, network, fetchedAt: Date.now(), tokenCount: allTokens.length };
+ * ```
+ *
+ * @typeParam T - Type of items being fetched
+ * @typeParam K - Network key type (e.g., 'ETHEREUM' | 'SOLANA')
+ * @param options - Options including network, cache, fetchFn, and logger
+ * @returns Promise resolving to items with fetchedAt timestamp and count
+ *
+ * @example Basic usage
+ * ```typescript
+ * const result = await fetchAllWithNetworkCache({
+ *   network: 'ETHEREUM',
+ *   cache: this.cache,
+ *   fetchFn: () => autoPaginateOffset(
+ *     async (offset, limit) => ({
+ *       items: this.transformTokens(response.tokens, network),
+ *       rawCount: response.tokens.length,
+ *     }),
+ *     { maxLimit: MAX_LIMIT, logger: this.logger }
+ *   ),
+ *   logger: this.logger,
+ *   itemTypeName: 'bridgeable tokens',
+ * });
+ * ```
+ *
+ * @since 5.10.0
+ */
+export declare function fetchAllWithNetworkCache<T, K extends string = string>(options: FetchAllWithNetworkCacheOptions<T, K>): Promise<FetchAllWithCacheResult<T>>;
+/**
+ * Result object from cursor-based paginated API calls
+ *
+ * @template T - Type of items being paginated
+ *
+ * @since 8.0.0
+ */
+export interface CursorPaginationResult<T> {
+    /** Array of items returned from this page */
+    items: T[];
+    /** Pagination cursor info */
+    pageInfo: PageInfo;
+}
+/**
+ * Options for cursor-based auto-pagination
+ *
+ * @since 8.0.0
+ */
+export interface AutoPaginationWithCursorOptions {
+    /** Maximum number of pages to fetch (safety limit to prevent infinite loops) */
+    maxPages?: number;
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Page size to use for each request (default: 50) */
+    pageSize?: number;
+}
+/**
+ * Cursor-based auto-pagination handler
+ *
+ * Automatically iterates through all pages of cursor-based paginated API results
+ * and combines them into a single array. Handles common patterns like:
+ * - Safety limits to prevent infinite loops
+ * - Empty result detection
+ * - Debug logging of pagination progress
+ * - Proper cursor extraction from API responses
+ *
+ * Used for APIs that return cursor tokens instead of page numbers or offsets.
+ *
+ * @typeParam T - Type of items being paginated
+ * @param fetchFn Function that fetches a single page given cursor and pageSize.
+ *                Should return { items: T[], pageInfo: PageInfo }
+ * @param options Pagination options (maxPages, logger, pageSize)
+ * @returns Promise<AutoPaginationResult> All items combined from all pages
+ *
+ * @example Basic cursor-based pagination
+ * ```typescript
+ * const result = await autoPaginateWithCursor(
+ *   async (cursor, pageSize) => {
+ *     const response = await api.list({ cursor, pageSize });
+ *     return {
+ *       items: response.items,
+ *       pageInfo: response.pageInfo
+ *     };
+ *   },
+ *   { maxPages: 1000, pageSize: 50, logger }
+ * );
+ * console.log(`Total fetched: ${result.items.length}`);
+ * ```
+ *
+ * @since 8.0.0
+ */
+export declare function autoPaginateWithCursor<T>(fetchFn: (cursor: string | undefined, pageSize: number) => Promise<CursorPaginationResult<T>>, options?: AutoPaginationWithCursorOptions): Promise<AutoPaginationResult<T>>;
+/**
+ * Build paginated result object with cursor-based pagination info
+ *
+ * Helper function to construct the standard cursor-based paginated result structure
+ * for returning combined auto-paginated data.
+ *
+ * @typeParam T - Type of items in the result
+ * @param items Combined array of all items from all pages
+ * @param pageInfo Pagination info (cursor, hasNextPage, etc.)
+ * @param itemsKey Optional field name for items (default: 'items')
+ * @returns Object with items and pageInfo for cursor pagination
+ *
+ * @example Basic usage
+ * ```typescript
+ * const allItems = await autoPaginateWithCursor(fetchFn);
+ * return buildPaginatedResultWithCursor(allItems.items, {
+ *   hasNextPage: false,
+ *   nextCursor: undefined,
+ *   totalCount: allItems.total
+ * });
+ * ```
+ *
+ * @since 8.0.0
+ */
+export declare function buildPaginatedResultWithCursor<T>(items: T[], pageInfo: PageInfo, itemsKey?: 'items' | 'pools' | 'snapshots' | string): Record<string, unknown>;
+//# sourceMappingURL=auto-pagination.d.ts.map

package/dist/utils/auto-pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-pagination.d.ts","sourceRoot":"","sources":["../../src/utils/auto-pagination.ts"],"names":[],"mappings":"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"}