Fix UnhandledPromiseRejection error on failed V2 List operations (#2571)

Fix UnhandlePromiseException on V2 List

Author: mbroshi-stripe

src/autoPagination.ts

@@ -146,8 +146,9 @@ class V1SearchIterator<T> extends V1Iterator<T> {
 }
 
 class V2ListIterator<T> implements AsyncIterator<T> {
-  private currentPageIterator: Promise<Iterator<T>>;
-  private nextPageUrl: Promise<string | null>;
+  private firstPagePromise: Promise<PageResult<T>> | null;
+  private currentPageIterator: Iterator<T> | null;
+  private nextPageUrl: string | null;
   private requestArgs: RequestArgs;
   private spec: MethodSpec;
   private stripeResource: StripeResourceObject;
@@ -157,32 +158,33 @@ class V2ListIterator<T> implements AsyncIterator<T> {
     spec: MethodSpec,
     stripeResource: StripeResourceObject
   ) {
-    this.currentPageIterator = (async (): Promise<Iterator<T>> => {
-      const page = await firstPagePromise;
-      return page.data[Symbol.iterator]();
-    })();
-
-    this.nextPageUrl = (async (): Promise<string | null> => {
-      const page = await firstPagePromise;
-      return page.next_page_url || null;
-    })();
-
+    this.firstPagePromise = firstPagePromise;
+    this.currentPageIterator = null;
+    this.nextPageUrl = null;
     this.requestArgs = requestArgs;
     this.spec = spec;
     this.stripeResource = stripeResource;
   }
+  private async initFirstPage(): Promise<void> {
+    if (this.firstPagePromise) {
+      const page = await this.firstPagePromise;
+      this.firstPagePromise = null;
+      this.currentPageIterator = page.data[Symbol.iterator]();
+      this.nextPageUrl = page.next_page_url || null;
+    }
+  }
   private async turnPage(): Promise<Iterator<T> | null> {
-    const nextPageUrl = await this.nextPageUrl;
-    if (!nextPageUrl) return null;
-    this.spec.fullPath = nextPageUrl;
+    if (!this.nextPageUrl) return null;
+    this.spec.fullPath = this.nextPageUrl;
     const page = await this.stripeResource._makeRequest([], this.spec, {});
-    this.nextPageUrl = Promise.resolve(page.next_page_url);
-    this.currentPageIterator = Promise.resolve(page.data[Symbol.iterator]());
+    this.nextPageUrl = page.next_page_url || null;
+    this.currentPageIterator = page.data[Symbol.iterator]();
     return this.currentPageIterator;
   }
   async next(): Promise<IteratorResult<T>> {
-    {
-      const result = (await this.currentPageIterator).next();
+    await this.initFirstPage();
+    if (this.currentPageIterator) {
+      const result = this.currentPageIterator.next();
       if (!result.done) return {done: false, value: result.value};
     }
     const nextPageIterator = await this.turnPage();

test/autoPagination.spec.ts

@@ -6,6 +6,7 @@ import {makeAutoPaginationMethods} from '../src/autoPagination.js';
 import {StripeResource} from '../src/StripeResource.js';
 import {getMockStripe} from './testUtils.js';
 import {MethodSpec} from '../src/Types.js';
+import {StripeAPIError} from '../src/Error.js';
 
 describe('auto pagination', () => {
   const testCase = (mockPaginationFn) => ({
@@ -841,6 +842,52 @@ describe('auto pagination', () => {
         ],
       });
     });
+
+    it('handles firstPagePromise rejection without unhandled promise rejection', async () => {
+      const spec = {
+        method: 'GET',
+        fullPath: '/v2/items',
+        methodType: 'list',
+      };
+
+      const mockStripe = getMockStripe({}, () => {});
+      const resource = new StripeResource(mockStripe);
+
+      // Track unhandled rejections
+      const unhandledRejections: Error[] = [];
+      const unhandledRejectionHandler = (reason: Error): void => {
+        unhandledRejections.push(reason);
+      };
+      process.on('unhandledRejection', unhandledRejectionHandler);
+
+      const error = new StripeAPIError({message: 'Something went wrong'});
+      const rejectingPromise = Promise.reject(error);
+
+      const paginator = makeAutoPaginationMethods(
+        resource,
+        {},
+        spec,
+        rejectingPromise
+      );
+
+      // User code catches the error via autoPagingToArray
+      try {
+        await paginator.autoPagingToArray({limit: 10});
+        expect.fail('Should have thrown an error');
+      } catch (e) {
+        expect(e.message).to.equal('Something went wrong');
+      }
+
+      // Give the event loop a chance to process any unhandled rejections
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      process.off('unhandledRejection', unhandledRejectionHandler);
+
+      expect(
+        unhandledRejections,
+        'Should not have any unhandled promise rejections'
+      ).to.have.length(0);
+    });
   });
 });