chore: generated code for commit 46c1526f. [skip ci]

algolia/api-clients-automation@46c1526

Co-authored-by: algolia-bot <[email protected]>
Co-authored-by: Clément Vannicatte <[email protected]>

Author: algolia-bot

bundlesize.config.json

@@ -2,7 +2,7 @@
   "files": [
     {
       "path": "packages/algoliasearch/dist/algoliasearch.umd.js",
-      "maxSize": "8.30KB"
+      "maxSize": "8.60KB"
     },
     {
       "path": "packages/algoliasearch/dist/lite/lite.umd.js",
@@ -30,7 +30,7 @@
     },
     {
       "path": "packages/client-search/dist/client-search.umd.js",
-      "maxSize": "6.60KB"
+      "maxSize": "6.90KB"
     },
     {
       "path": "packages/client-sources/dist/client-sources.umd.js",

packages/algoliasearch/lite/src/liteClient.ts

@@ -89,12 +89,14 @@ export function createLiteClient({
 
   return {
     transporter,
+
     /**
      * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
      */
     get _ua(): string {
       return transporter.algoliaAgent.value;
     },
+
     /**
      * Adds a `segment` to the `x-algolia-agent` sent with every requests.
      *
@@ -104,6 +106,7 @@ export function createLiteClient({
     addAlgoliaAgent(segment: string, version?: string): void {
       transporter.algoliaAgent.add({ segment, version });
     },
+
     /**
      * This method allow you to send requests to the Algolia REST API.
      *

packages/client-abtesting/src/abtestingClient.ts

@@ -73,12 +73,14 @@ export function createAbtestingClient({
 
   return {
     transporter,
+
     /**
      * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
      */
     get _ua(): string {
       return transporter.algoliaAgent.value;
     },
+
     /**
      * Adds a `segment` to the `x-algolia-agent` sent with every requests.
      *
@@ -88,6 +90,7 @@ export function createAbtestingClient({
     addAlgoliaAgent(segment: string, version?: string): void {
       transporter.algoliaAgent.add({ segment, version });
     },
+
     /**
      * Creates a new A/B test with provided configuration. You can set an A/B test on two different indices with different settings, or on the same index with different search parameters by providing a customSearchParameters setting on one of the variants.
      *

packages/client-analytics/src/analyticsClient.ts

@@ -99,12 +99,14 @@ export function createAnalyticsClient({
 
   return {
     transporter,
+
     /**
      * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
      */
     get _ua(): string {
       return transporter.algoliaAgent.value;
     },
+
     /**
      * Adds a `segment` to the `x-algolia-agent` sent with every requests.
      *
@@ -114,6 +116,7 @@ export function createAnalyticsClient({
     addAlgoliaAgent(segment: string, version?: string): void {
       transporter.algoliaAgent.add({ segment, version });
     },
+
     /**
      * This method allow you to send requests to the Algolia REST API.
      *

packages/client-common/index.ts

@@ -1,6 +1,6 @@
 export * from './src/createAuth';
 export * from './src/createEchoRequester';
-export * from './src/createRetryablePromise';
+export * from './src/createIterablePromise';
 export * from './src/cache';
 export * from './src/transporter';
 export * from './src/createAlgoliaAgent';

packages/client-common/jest.config.ts

@@ -14,6 +14,7 @@ const config: Config.InitialOptions = {
       testPathIgnorePatterns: [
         'src/__tests__/cache/null-cache.test.ts',
         'src/__tests__/cache/memory-cache.test.ts',
+        'src/__tests__/create-iterable-promise.test.ts',
       ],
     },
     {

packages/client-common/src/__tests__/create-iterable-promise.test.ts

@@ -0,0 +1,238 @@
+import { createIterablePromise } from '../createIterablePromise';
+
+describe('createIterablePromise', () => {
+  describe('func', () => {
+    it('provides the `previousResponse` parameter', async () => {
+      const responses: Array<string | undefined> = [];
+      const promise = createIterablePromise<string | undefined>({
+        func: (previousResponse) => {
+          return new Promise((resolve) => {
+            resolve(previousResponse === undefined ? 'yes' : 'no');
+          });
+        },
+        validate: () => responses.length === 3,
+        aggregator: (response) => responses.push(response),
+      });
+
+      await expect(promise).resolves.toEqual('no');
+      expect(responses).toEqual(['yes', 'no', 'no']);
+    });
+  });
+
+  describe('validate', () => {
+    it('iterates on a `func` until `validate` is met', async () => {
+      let calls = 0;
+      const promise = createIterablePromise({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            resolve(`success #${calls}`);
+          });
+        },
+        validate: () => calls >= 3,
+      });
+
+      await expect(promise).resolves.toEqual('success #3');
+      expect(calls).toBe(3);
+    });
+
+    it('forward the response of the `func`', async () => {
+      let calls = 0;
+      const promise = createIterablePromise<number>({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            resolve(calls);
+          });
+        },
+        validate: (response) => response >= 3,
+      });
+
+      await expect(promise).resolves.toEqual(3);
+      expect(calls).toBe(3);
+    });
+  });
+
+  describe('aggregator', () => {
+    it('is called before iterating', async () => {
+      let calls = 0;
+      let count = 0;
+      const promise = createIterablePromise({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            resolve(`success #${calls}`);
+          });
+        },
+        validate: () => calls >= 3,
+        aggregator: () => (count += 3),
+      });
+
+      await expect(promise).resolves.toEqual('success #3');
+      expect(calls).toBe(3);
+      expect(count).toBe(3 * 3);
+    });
+
+    it('forward the response of the `func`', async () => {
+      let calls = 0;
+      const responses: string[] = [];
+      const promise = createIterablePromise<string>({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            resolve(`success #${calls}`);
+          });
+        },
+        validate: () => calls >= 3,
+        aggregator: (response) => {
+          responses.push(response);
+        },
+      });
+
+      await expect(promise).resolves.toEqual('success #3');
+      expect(calls).toBe(3);
+      expect(responses).toEqual(['success #1', 'success #2', 'success #3']);
+    });
+  });
+
+  describe('timeout', () => {
+    it('defaults to no timeout (0)', async () => {
+      let calls = 0;
+      const before = Date.now();
+      const promise = createIterablePromise({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            resolve(`success #${calls}`);
+          });
+        },
+        validate: () => calls >= 2,
+      });
+
+      await expect(promise).resolves.toEqual('success #2');
+
+      expect(Date.now() - before).toBeGreaterThanOrEqual(0);
+      expect(Date.now() - before).toBeLessThan(10);
+      expect(calls).toBe(2);
+    });
+
+    it('waits before calling the `func` again', async () => {
+      let calls = 0;
+      const before = Date.now();
+      const promise = createIterablePromise({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            resolve(`success #${calls}`);
+          });
+        },
+        validate: () => calls >= 2,
+        timeout: () => 2000,
+      });
+
+      await expect(promise).resolves.toEqual('success #2');
+
+      expect(Date.now() - before).toBeGreaterThanOrEqual(2000);
+      expect(Date.now() - before).toBeLessThan(2010);
+      expect(calls).toBe(2);
+    });
+  });
+
+  describe('error', () => {
+    it('gets the rejection of the given promise via reject', async () => {
+      let calls = 0;
+
+      const promise = createIterablePromise({
+        func: () => {
+          return new Promise((resolve, reject) => {
+            calls += 1;
+            if (calls <= 3) {
+              resolve('okay');
+            } else {
+              reject(new Error('nope'));
+            }
+          });
+        },
+        validate: () => false,
+      });
+
+      await expect(promise).rejects.toEqual(
+        expect.objectContaining({ message: 'nope' })
+      );
+    });
+
+    it('gets the rejection of the given promise via throw', async () => {
+      let calls = 0;
+
+      const promise = createIterablePromise({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            if (calls <= 3) {
+              resolve('okay');
+            } else {
+              throw new Error('nope');
+            }
+          });
+        },
+        validate: () => false,
+      });
+
+      await expect(promise).rejects.toEqual(
+        expect.objectContaining({ message: 'nope' })
+      );
+    });
+
+    it('rejects with the given `message` when `validate` hits', async () => {
+      const MAX_RETRIES = 3;
+      let calls = 0;
+
+      const promise = createIterablePromise({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            resolve('okay');
+          });
+        },
+        validate: () => false,
+        error: {
+          validate: () => calls >= MAX_RETRIES,
+          message: () => `Error is thrown: ${calls}/${MAX_RETRIES}`,
+        },
+      });
+
+      await expect(promise).rejects.toEqual(
+        expect.objectContaining({
+          message: 'Error is thrown: 3/3',
+        })
+      );
+      expect(calls).toBe(MAX_RETRIES);
+    });
+
+    it('forward the response of the `func`', async () => {
+      const MAX_RETRIES = 3;
+      let calls = 0;
+
+      const promise = createIterablePromise<number>({
+        func: () => {
+          return new Promise((resolve) => {
+            calls += 1;
+            resolve(calls);
+          });
+        },
+        validate: () => false,
+        error: {
+          validate: (response) => response >= MAX_RETRIES,
+          message: (response) => `Error is thrown: ${response}/${MAX_RETRIES}`,
+        },
+      });
+
+      await expect(promise).rejects.toEqual(
+        expect.objectContaining({
+          message: 'Error is thrown: 3/3',
+        })
+      );
+      expect(calls).toBe(MAX_RETRIES);
+    });
+  });
+});