@zapier/zapier-sdk 0.13.6 → 0.13.8

package/src/utils/pagination-utils.test.ts

@@ -1,620 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { paginate, paginateMaxItems } from "./pagination-utils";
-
-// Test data set - simulating a large dataset with cursor-based pagination
-export const ALL_ITEMS = Array.from({ length: 25 }, (_, i) => ({
-  id: i + 1,
-  name: `Item ${i + 1}`,
-}));
-
-// Test page function that implements cursor-based pagination logic
-export async function listTestItems(options: {
-  pageSize?: number;
-  cursor?: string;
-  filter?: string;
-  maxItems?: number;
-}) {
-  const { pageSize = 5, cursor, filter, maxItems } = options;
-
-  // Cap pageSize at 10 to simulate real API limits
-  let actualPageSize = Math.min(pageSize, 10);
-
-  // If maxItems hint is provided, further limit the page size for optimization
-  if (maxItems !== undefined && maxItems > 0) {
-    actualPageSize = Math.min(actualPageSize, maxItems);
-  }
-
-  // Filter items if filter is provided
-  let items = ALL_ITEMS;
-  if (filter) {
-    items = items.filter((item) =>
-      item.name.toLowerCase().includes(filter.toLowerCase()),
-    );
-  }
-
-  // Find starting position based on cursor
-  let startIndex = 0;
-  if (cursor) {
-    // Cursor format: "cursor-{itemId}"
-    const cursorId = parseInt(cursor.replace("cursor-", ""));
-    startIndex = items.findIndex((item) => item.id > cursorId);
-    if (startIndex === -1) {
-      // No more items after cursor
-      return { data: [], nextCursor: undefined };
-    }
-  }
-
-  // Get page of items
-  const pageItems = items.slice(startIndex, startIndex + actualPageSize);
-
-  // Determine next cursor
-  let nextCursor: string | undefined;
-  if (startIndex + actualPageSize < items.length && pageItems.length > 0) {
-    const lastItem = pageItems[pageItems.length - 1];
-    nextCursor = `cursor-${lastItem.id}`;
-  }
-
-  return {
-    data: pageItems,
-    nextCursor,
-  };
-}
-
-describe("paginate", () => {
-  it("should paginate through multiple pages", async () => {
-    const pageIterator = paginate(listTestItems, { pageSize: 3 });
-
-    const pages = [];
-    for await (const page of pageIterator) {
-      pages.push(page);
-    }
-
-    // With 25 items and pageSize 3, should have 9 pages (8 full + 1 partial)
-    expect(pages).toHaveLength(9);
-
-    // Check first page
-    expect(pages[0]).toEqual({
-      data: ALL_ITEMS.slice(0, 3),
-      nextCursor: "cursor-3",
-    });
-
-    // Check second page (cursor should be passed correctly)
-    expect(pages[1]).toEqual({
-      data: ALL_ITEMS.slice(3, 6),
-      nextCursor: "cursor-6",
-    });
-
-    // Check last page (should have no nextCursor)
-    expect(pages[8]).toEqual({
-      data: ALL_ITEMS.slice(24, 25),
-      nextCursor: undefined,
-    });
-
-    // Verify we got all 25 items across all pages
-    const allItems = pages.flatMap((page) => page.data);
-    expect(allItems).toHaveLength(25);
-  });
-
-  it("should cap pageSize at 10 when unbuffered", async () => {
-    // Use a page size larger than 10, should get capped
-    const pageIterator = paginateMaxItems(listTestItems, { pageSize: 50 });
-
-    const pages = [];
-    for await (const page of pageIterator) {
-      pages.push(page);
-    }
-
-    // Should get 3 pages: 10+10+5=25 (pageSize capped at 10)
-    expect(pages).toHaveLength(3);
-    expect(pages[0].data).toHaveLength(10); // First page capped at 10
-    expect(pages[1].data).toHaveLength(10); // Second page capped at 10
-    expect(pages[2].data).toHaveLength(5); // Last page has remaining 5
-    expect(pages[2].nextCursor).toBeUndefined(); // Last page has no nextCursor
-  });
-
-  it("should not cap pageSize when buffered", async () => {
-    const pageIterator = paginate(listTestItems, { pageSize: 50 });
-
-    for await (const page of pageIterator) {
-      expect(page.data).toHaveLength(25);
-      break;
-    }
-  });
-
-  it("should not cap pageSize when buffered", async () => {
-    const pageIterator = paginate(listTestItems, { pageSize: 15 });
-
-    const pages = [];
-    for await (const page of pageIterator) {
-      pages.push(page);
-    }
-
-    expect(pages).toHaveLength(2);
-    expect(pages[0].data).toHaveLength(15);
-    expect(pages[1].data).toHaveLength(10);
-  });
-
-  it("should continue from pseudo cursor", async () => {
-    const pageIterator = paginate(listTestItems, { pageSize: 15 });
-
-    const pages = [];
-    for await (const page of pageIterator) {
-      pages.push(page);
-      break;
-    }
-
-    const nextPageIterator = paginate(listTestItems, {
-      pageSize: 15,
-      cursor: pages[0].nextCursor,
-    });
-
-    for await (const page of nextPageIterator) {
-      pages.push(page);
-    }
-
-    expect(pages).toHaveLength(2);
-    expect(pages[0].data).toHaveLength(15);
-    expect(pages[1].data).toHaveLength(10);
-  });
-
-  it("should handle filtered results", async () => {
-    // Filter for items containing "1" (should match Item 1, Item 10-19, Item 21)
-    const pageIterator = paginate(listTestItems, {
-      pageSize: 4,
-      filter: "1",
-    });
-
-    const pages = [];
-    for await (const page of pageIterator) {
-      pages.push(page);
-    }
-
-    // Should have multiple pages due to pageSize: 4
-    expect(pages.length).toBeGreaterThan(1);
-
-    // All items should contain "1"
-    const allItems = pages.flatMap((page) => page.data);
-    expect(allItems.every((item) => item.name.includes("1"))).toBe(true);
-
-    // Should include items like Item 1, Item 10, Item 11, etc.
-    expect(allItems).toContainEqual(ALL_ITEMS[0]); // Item 1
-    expect(allItems).toContainEqual(ALL_ITEMS[9]); // Item 10
-    expect(allItems).toContainEqual(ALL_ITEMS[20]); // Item 21
-  });
-
-  it("should handle empty results", async () => {
-    // Filter that matches no items
-    const pageIterator = paginate(listTestItems, {
-      pageSize: 10,
-      filter: "nonexistent",
-    });
-
-    const pages = [];
-    for await (const page of pageIterator) {
-      pages.push(page);
-    }
-
-    expect(pages).toHaveLength(1);
-    expect(pages[0]).toEqual({
-      data: [],
-      nextCursor: undefined,
-    });
-  });
-
-  it("should pass through errors from the page function", async () => {
-    // Create a page function that throws an error
-    const errorPageFunction = async () => {
-      throw new Error("Page function failed");
-    };
-
-    const pageIterator = paginate(errorPageFunction, {});
-
-    let reachedUnreachableCode: any = undefined;
-
-    await expect(async () => {
-      for await (const page of pageIterator) {
-        // Should never reach here due to error
-        reachedUnreachableCode = page;
-      }
-    }).rejects.toThrow("Page function failed");
-
-    // Verify we never reached the unreachable code
-    expect(reachedUnreachableCode).toBeUndefined();
-  });
-
-  it("should start pagination from provided cursor", async () => {
-    // Test that pagination can start from a specific cursor position
-    const pageIterator = paginate(listTestItems, {
-      pageSize: 3,
-      cursor: "cursor-5", // Start after item 5
-    });
-
-    const pages = [];
-    for await (const page of pageIterator) {
-      pages.push(page);
-      if (pages.length >= 2) break; // Just test first 2 pages
-    }
-
-    expect(pages).toHaveLength(2);
-
-    // First page should start after cursor-5 (from item 6)
-    expect(pages[0].data[0]).toEqual(ALL_ITEMS[5]); // Item 6
-
-    // Second page should continue properly
-    expect(pages[1].data[0]).toEqual(ALL_ITEMS[8]); // Item 9
-  });
-
-  it("should allow breaking out of pagination early", async () => {
-    // Test that users can break out of the iterator manually
-    const pageIterator = paginate(listTestItems, { pageSize: 3 });
-
-    const pages = [];
-    for await (const page of pageIterator) {
-      pages.push(page);
-
-      // Break after getting 3 pages
-      if (pages.length >= 3) {
-        break;
-      }
-    }
-
-    // Should have stopped at exactly 3 pages with 9 items (3+3+3=9)
-    const allItems = pages.flatMap((page) => page.data);
-    expect(allItems).toHaveLength(9);
-    expect(pages).toHaveLength(3);
-
-    // Should be first 9 items
-    expect(allItems).toEqual(ALL_ITEMS.slice(0, 9));
-  });
-
-  describe("conditional types for optional options", () => {
-    it("should work with function that takes no options", async () => {
-      async function fetchWithNoOptions(_options?: {
-        maxItems?: number;
-        cursor?: string;
-      }): Promise<{
-        data: number[];
-        nextCursor?: string;
-      }> {
-        return { data: [1, 2, 3] };
-      }
-
-      const pages: number[] = [];
-      for await (const page of paginate(fetchWithNoOptions)) {
-        pages.push(...page.data);
-      }
-
-      expect(pages).toEqual([1, 2, 3]);
-    });
-
-    it("should work with function that takes optional options", async () => {
-      async function fetchWithOptionalOptions(options?: {
-        limit?: number;
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{ data: string[]; nextCursor?: string }> {
-        return { data: [`page-${options?.cursor || "1"}`] };
-      }
-
-      const pages: string[] = [];
-      for await (const page of paginate(fetchWithOptionalOptions, {
-        limit: 5,
-      })) {
-        pages.push(...page.data);
-      }
-
-      expect(pages).toEqual(["page-1"]);
-    });
-
-    it("should work with function that takes only cursor", async () => {
-      async function fetchWithOnlyCursor(_options: {
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{ data: boolean[]; nextCursor?: string }> {
-        return { data: [true] };
-      }
-
-      const pages: boolean[] = [];
-      for await (const page of paginate(fetchWithOnlyCursor, {
-        cursor: "start",
-      })) {
-        pages.push(...page.data);
-      }
-
-      expect(pages).toEqual([true]);
-    });
-
-    it("should work when baseOptions is omitted entirely", async () => {
-      async function fetchSimple(_options?: {
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{
-        data: string[];
-        nextCursor?: string;
-      }> {
-        return { data: ["simple"] };
-      }
-
-      const pages: string[] = [];
-      for await (const page of paginate(fetchSimple)) {
-        pages.push(...page.data);
-      }
-
-      expect(pages).toEqual(["simple"]);
-    });
-  });
-
-  describe("maxItems functionality", () => {
-    it("should limit total items across pages", async () => {
-      const items: typeof ALL_ITEMS = [];
-
-      for await (const page of paginate(listTestItems, {
-        pageSize: 3,
-        maxItems: 7,
-      })) {
-        items.push(...page.data);
-      }
-
-      expect(items).toHaveLength(7);
-      expect(items).toEqual(ALL_ITEMS.slice(0, 7));
-    });
-
-    it("should truncate the final page when maxItems is exceeded", async () => {
-      // Create a function that ignores maxItems hint to force truncation
-
-      async function fetchIgnoringMaxItems(options: {
-        pageSize?: number;
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{ data: typeof ALL_ITEMS; nextCursor?: string }> {
-        return listTestItems({
-          pageSize: options.pageSize,
-          cursor: options.cursor,
-        });
-      }
-
-      const pageData: { data: typeof ALL_ITEMS; nextCursor?: string }[] = [];
-
-      for await (const page of paginate(fetchIgnoringMaxItems, {
-        pageSize: 3,
-        maxItems: 7,
-      })) {
-        pageData.push(page);
-      }
-
-      // Should have 3 pages: [3 items], [3 items], [1 item (truncated)]
-      expect(pageData).toHaveLength(3);
-      expect(pageData[0].data).toHaveLength(3);
-      expect(pageData[1].data).toHaveLength(3);
-      expect(pageData[2].data).toHaveLength(1); // Truncated page
-      expect(pageData[2].nextCursor).toBeUndefined(); // Should clear cursor
-    });
-
-    it("should stop early when maxItems is exactly a page boundary", async () => {
-      const items: typeof ALL_ITEMS = [];
-
-      for await (const page of paginate(listTestItems, {
-        pageSize: 3,
-        maxItems: 6,
-      })) {
-        items.push(...page.data);
-      }
-
-      expect(items).toHaveLength(6);
-      expect(items).toEqual(ALL_ITEMS.slice(0, 6));
-    });
-
-    it("should handle maxItems of 0", async () => {
-      const items: typeof ALL_ITEMS = [];
-
-      for await (const page of paginate(listTestItems, {
-        pageSize: 3,
-        maxItems: 0,
-      })) {
-        items.push(...page.data);
-      }
-
-      expect(items).toHaveLength(0);
-    });
-
-    it("should work normally when maxItems is larger than total items", async () => {
-      const items: typeof ALL_ITEMS = [];
-
-      for await (const page of paginate(listTestItems, {
-        pageSize: 3,
-        maxItems: 100,
-      })) {
-        items.push(...page.data);
-      }
-
-      // Should get all items since limit is higher than total
-      expect(items).toEqual(ALL_ITEMS);
-    });
-
-    it("should work with maxItems and other options combined", async () => {
-      async function fetchWithLimit(options: {
-        limit: number;
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{ data: typeof ALL_ITEMS; nextCursor?: string }> {
-        const start = parseInt(options.cursor || "0");
-        let limit = options.limit;
-
-        // Apply maxItems hint for optimization
-        if (options.maxItems !== undefined && options.maxItems > 0) {
-          limit = Math.min(limit, options.maxItems);
-        }
-
-        const items = ALL_ITEMS.slice(start, start + limit);
-        const nextCursor =
-          start + limit < ALL_ITEMS.length
-            ? (start + limit).toString()
-            : undefined;
-        return { data: items, nextCursor };
-      }
-
-      const items: typeof ALL_ITEMS = [];
-
-      for await (const page of paginate(fetchWithLimit, {
-        limit: 2,
-        maxItems: 5,
-      })) {
-        items.push(...page.data);
-      }
-
-      expect(items).toHaveLength(5);
-      expect(items).toEqual(ALL_ITEMS.slice(0, 5));
-    });
-
-    it("should preserve original page structure except for truncation", async () => {
-      // Create a function that ignores maxItems hint to force truncation
-      async function fetchIgnoringMaxItems(options: {
-        pageSize?: number;
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{ data: typeof ALL_ITEMS; nextCursor?: string }> {
-        const pageSize = options.pageSize || 3;
-        const start = options.cursor
-          ? parseInt(options.cursor.replace("cursor-", "")) + 1
-          : 0;
-        const items = ALL_ITEMS.slice(start, start + pageSize);
-        const nextCursor =
-          start + pageSize <= ALL_ITEMS.length
-            ? `cursor-${ALL_ITEMS[start + pageSize - 1].id}`
-            : undefined;
-        return { data: items, nextCursor };
-      }
-
-      let pageCount = 0;
-
-      for await (const page of paginate(fetchIgnoringMaxItems, {
-        pageSize: 3,
-        maxItems: 7,
-      })) {
-        pageCount++;
-
-        // All pages should have the expected structure
-        expect(page).toHaveProperty("data");
-        expect(Array.isArray(page.data)).toBe(true);
-
-        if (pageCount === 3) {
-          // Final truncated page
-          expect(page.data).toHaveLength(1);
-          expect(page.nextCursor).toBeUndefined();
-        } else {
-          // Regular pages
-          expect(page.data).toHaveLength(3);
-          expect(typeof page.nextCursor).toBe("string");
-        }
-      }
-
-      expect(pageCount).toBe(3);
-    });
-
-    it("should handle API that ignores pageSize and returns more items on first page", async () => {
-      // Simulate an API that ignores pageSize and always returns 10 items per page
-      async function apiIgnoresPageSize(options: {
-        pageSize?: number;
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{ data: typeof ALL_ITEMS; nextCursor?: string }> {
-        return listTestItems({
-          cursor: options.cursor,
-          pageSize: 10,
-        });
-      }
-
-      const pages: { data: typeof ALL_ITEMS; nextCursor?: string }[] = [];
-
-      // User requests pageSize: 3, but API returns 10 per page
-      for await (const page of paginate(apiIgnoresPageSize, {
-        pageSize: 3,
-      })) {
-        pages.push(page);
-        // Only get first page to test the behavior
-        break;
-      }
-
-      // Should get 1 page with only 3 items (paginate enforces pageSize limit)
-      expect(pages).toHaveLength(1);
-      expect(pages[0].data).toHaveLength(3);
-      expect(pages[0].data).toEqual(ALL_ITEMS.slice(0, 3));
-      // Cursor should still be present since there are more items available
-      expect(pages[0].nextCursor).toBeDefined();
-    });
-
-    it("should truncate oversized API response to pageSize", async () => {
-      // API always returns 10 items, but user wants pageSize: 3
-      async function apiReturns10Items(options: {
-        pageSize?: number;
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{ data: typeof ALL_ITEMS; nextCursor?: string }> {
-        return listTestItems({
-          cursor: options.cursor,
-          pageSize: 10,
-        });
-      }
-
-      const pages: { data: typeof ALL_ITEMS; nextCursor?: string }[] = [];
-
-      for await (const page of paginate(apiReturns10Items, {
-        pageSize: 3,
-      })) {
-        pages.push(page);
-      }
-
-      // Should truncate each 10-item API response to 3 items per page
-      expect(pages).toHaveLength(9);
-      expect(pages[0].data).toHaveLength(3);
-      expect(pages[1].data).toHaveLength(3);
-      expect(pages[8].data).toHaveLength(1);
-
-      // Verify items are from different API calls
-      expect(pages[0].data).toEqual(ALL_ITEMS.slice(0, 3)); // Items 1-3 from first API call
-      expect(pages[1].data).toEqual(ALL_ITEMS.slice(3, 6)); // Items 11-13 from second API call
-      expect(pages[8].data).toEqual(ALL_ITEMS.slice(24, 25)); // Items 21-23 from third API call
-
-      // All pages should have nextCursor since API has more data
-      expect(pages[0].nextCursor).toBe('["$$offset$$",3,null]');
-      expect(pages[8].nextCursor).toBeUndefined();
-    });
-
-    it("should handle pageSize enforcement with maxItems limit", async () => {
-      // API returns 10 items, user wants pageSize: 3, maxItems: 7
-      async function apiReturns10Items(options: {
-        pageSize?: number;
-        cursor?: string;
-        maxItems?: number;
-      }): Promise<{ data: typeof ALL_ITEMS; nextCursor?: string }> {
-        return listTestItems({
-          cursor: options.cursor,
-          pageSize: 10,
-        });
-      }
-
-      const pages: { data: typeof ALL_ITEMS; nextCursor?: string }[] = [];
-
-      for await (const page of paginate(apiReturns10Items, {
-        pageSize: 3,
-        maxItems: 7,
-      })) {
-        pages.push(page);
-      }
-
-      // Should get: [3, 3, 1] items (total 7, respecting maxItems)
-      expect(pages).toHaveLength(3);
-      expect(pages[0].data).toHaveLength(3);
-      expect(pages[1].data).toHaveLength(3);
-      expect(pages[2].data).toHaveLength(1); // Truncated to respect maxItems
-
-      // Last page should have no nextCursor (maxItems reached)
-      expect(pages[2].nextCursor).toBeUndefined();
-
-      // Verify total items
-      const allItems = pages.flatMap((p) => p.data);
-      expect(allItems).toHaveLength(7);
-      expect(allItems).toEqual(ALL_ITEMS.slice(0, 7));
-    });
-  });
-});