@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.1

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

@@ -1,549 +0,0 @@
-/**
- * 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/src/utils/auto-pagination.d.ts.map

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