@algolia/client-common 5.8.1 → 5.9.0

package/src/__tests__/create-iterable-promise.test.ts

@@ -1,236 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { createIterablePromise } from '../createIterablePromise';
-
-describe('createIterablePromise', () => {
-  describe('func', () => {
-    test('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', () => {
-    test('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);
-    });
-
-    test('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', () => {
-    test('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);
-    });
-
-    test('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', () => {
-    test('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).toBeLessThanOrEqual(20);
-      expect(calls).toBe(2);
-    });
-
-    test('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).toBeLessThanOrEqual(2020);
-      expect(calls).toBe(2);
-    });
-  });
-
-  describe('error', () => {
-    test('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' }));
-    });
-
-    test('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' }));
-    });
-
-    test('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);
-    });
-
-    test('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);
-    });
-  });
-});

package/src/__tests__/logger/null-logger.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-
-import { createNullLogger } from '../../logger';
-
-describe('null logger', () => {
-  test('has a null behavior', async () => {
-    vi.resetAllMocks();
-    vi.spyOn(console, 'debug');
-    vi.spyOn(console, 'info');
-    vi.spyOn(console, 'error');
-
-    const logger = createNullLogger();
-
-    await logger.debug('foo', {});
-    await logger.info('foo', {});
-    await logger.error('foo', {});
-
-    expect(console.debug).toHaveBeenCalledTimes(0);
-    expect(console.info).toHaveBeenCalledTimes(0);
-    expect(console.error).toHaveBeenCalledTimes(0);
-  });
-});

package/src/cache/createBrowserLocalStorageCache.ts

@@ -1,106 +0,0 @@
-import type { BrowserLocalStorageCacheItem, BrowserLocalStorageOptions, Cache, CacheEvents } from '../types';
-
-export function createBrowserLocalStorageCache(options: BrowserLocalStorageOptions): Cache {
-  let storage: Storage;
-  // We've changed the namespace to avoid conflicts with v4, as this version is a huge breaking change
-  const namespaceKey = `algolia-client-js-${options.key}`;
-
-  function getStorage(): Storage {
-    if (storage === undefined) {
-      storage = options.localStorage || window.localStorage;
-    }
-
-    return storage;
-  }
-
-  function getNamespace<TValue>(): Record<string, TValue> {
-    return JSON.parse(getStorage().getItem(namespaceKey) || '{}');
-  }
-
-  function setNamespace(namespace: Record<string, any>): void {
-    getStorage().setItem(namespaceKey, JSON.stringify(namespace));
-  }
-
-  function removeOutdatedCacheItems(): void {
-    const timeToLive = options.timeToLive ? options.timeToLive * 1000 : null;
-    const namespace = getNamespace<BrowserLocalStorageCacheItem>();
-
-    const filteredNamespaceWithoutOldFormattedCacheItems = Object.fromEntries(
-      Object.entries(namespace).filter(([, cacheItem]) => {
-        return cacheItem.timestamp !== undefined;
-      }),
-    );
-
-    setNamespace(filteredNamespaceWithoutOldFormattedCacheItems);
-
-    if (!timeToLive) {
-      return;
-    }
-
-    const filteredNamespaceWithoutExpiredItems = Object.fromEntries(
-      Object.entries(filteredNamespaceWithoutOldFormattedCacheItems).filter(([, cacheItem]) => {
-        const currentTimestamp = new Date().getTime();
-        const isExpired = cacheItem.timestamp + timeToLive < currentTimestamp;
-
-        return !isExpired;
-      }),
-    );
-
-    setNamespace(filteredNamespaceWithoutExpiredItems);
-  }
-
-  return {
-    get<TValue>(
-      key: Record<string, any> | string,
-      defaultValue: () => Promise<TValue>,
-      events: CacheEvents<TValue> = {
-        miss: () => Promise.resolve(),
-      },
-    ): Promise<TValue> {
-      return Promise.resolve()
-        .then(() => {
-          removeOutdatedCacheItems();
-
-          return getNamespace<Promise<BrowserLocalStorageCacheItem>>()[JSON.stringify(key)];
-        })
-        .then((value) => {
-          return Promise.all([value ? value.value : defaultValue(), value !== undefined]);
-        })
-        .then(([value, exists]) => {
-          return Promise.all([value, exists || events.miss(value)]);
-        })
-        .then(([value]) => value);
-    },
-
-    set<TValue>(key: Record<string, any> | string, value: TValue): Promise<TValue> {
-      return Promise.resolve().then(() => {
-        const namespace = getNamespace();
-
-        namespace[JSON.stringify(key)] = {
-          timestamp: new Date().getTime(),
-          value,
-        };
-
-        getStorage().setItem(namespaceKey, JSON.stringify(namespace));
-
-        return value;
-      });
-    },
-
-    delete(key: Record<string, any> | string): Promise<void> {
-      return Promise.resolve().then(() => {
-        const namespace = getNamespace();
-
-        delete namespace[JSON.stringify(key)];
-
-        getStorage().setItem(namespaceKey, JSON.stringify(namespace));
-      });
-    },
-
-    clear(): Promise<void> {
-      return Promise.resolve().then(() => {
-        getStorage().removeItem(namespaceKey);
-      });
-    },
-  };
-}

package/src/cache/createFallbackableCache.ts

@@ -1,43 +0,0 @@
-import type { Cache, CacheEvents, FallbackableCacheOptions } from '../types';
-import { createNullCache } from './createNullCache';
-
-export function createFallbackableCache(options: FallbackableCacheOptions): Cache {
-  const caches = [...options.caches];
-  const current = caches.shift();
-
-  if (current === undefined) {
-    return createNullCache();
-  }
-
-  return {
-    get<TValue>(
-      key: Record<string, any> | string,
-      defaultValue: () => Promise<TValue>,
-      events: CacheEvents<TValue> = {
-        miss: (): Promise<void> => Promise.resolve(),
-      },
-    ): Promise<TValue> {
-      return current.get(key, defaultValue, events).catch(() => {
-        return createFallbackableCache({ caches }).get(key, defaultValue, events);
-      });
-    },
-
-    set<TValue>(key: Record<string, any> | string, value: TValue): Promise<TValue> {
-      return current.set(key, value).catch(() => {
-        return createFallbackableCache({ caches }).set(key, value);
-      });
-    },
-
-    delete(key: Record<string, any> | string): Promise<void> {
-      return current.delete(key).catch(() => {
-        return createFallbackableCache({ caches }).delete(key);
-      });
-    },
-
-    clear(): Promise<void> {
-      return current.clear().catch(() => {
-        return createFallbackableCache({ caches }).clear();
-      });
-    },
-  };
-}

package/src/cache/createMemoryCache.ts

@@ -1,43 +0,0 @@
-import type { Cache, CacheEvents, MemoryCacheOptions } from '../types';
-
-export function createMemoryCache(options: MemoryCacheOptions = { serializable: true }): Cache {
-  let cache: Record<string, any> = {};
-
-  return {
-    get<TValue>(
-      key: Record<string, any> | string,
-      defaultValue: () => Promise<TValue>,
-      events: CacheEvents<TValue> = {
-        miss: (): Promise<void> => Promise.resolve(),
-      },
-    ): Promise<TValue> {
-      const keyAsString = JSON.stringify(key);
-
-      if (keyAsString in cache) {
-        return Promise.resolve(options.serializable ? JSON.parse(cache[keyAsString]) : cache[keyAsString]);
-      }
-
-      const promise = defaultValue();
-
-      return promise.then((value: TValue) => events.miss(value)).then(() => promise);
-    },
-
-    set<TValue>(key: Record<string, any> | string, value: TValue): Promise<TValue> {
-      cache[JSON.stringify(key)] = options.serializable ? JSON.stringify(value) : value;
-
-      return Promise.resolve(value);
-    },
-
-    delete(key: Record<string, unknown> | string): Promise<void> {
-      delete cache[JSON.stringify(key)];
-
-      return Promise.resolve();
-    },
-
-    clear(): Promise<void> {
-      cache = {};
-
-      return Promise.resolve();
-    },
-  };
-}

package/src/cache/createNullCache.ts

@@ -1,29 +0,0 @@
-import type { Cache, CacheEvents } from '../types';
-
-export function createNullCache(): Cache {
-  return {
-    get<TValue>(
-      _key: Record<string, any> | string,
-      defaultValue: () => Promise<TValue>,
-      events: CacheEvents<TValue> = {
-        miss: (): Promise<void> => Promise.resolve(),
-      },
-    ): Promise<TValue> {
-      const value = defaultValue();
-
-      return value.then((result) => Promise.all([result, events.miss(result)])).then(([result]) => result);
-    },
-
-    set<TValue>(_key: Record<string, any> | string, value: TValue): Promise<TValue> {
-      return Promise.resolve(value);
-    },
-
-    delete(_key: Record<string, any> | string): Promise<void> {
-      return Promise.resolve();
-    },
-
-    clear(): Promise<void> {
-      return Promise.resolve();
-    },
-  };
-}

package/src/cache/index.ts

@@ -1,4 +0,0 @@
-export * from './createBrowserLocalStorageCache';
-export * from './createFallbackableCache';
-export * from './createMemoryCache';
-export * from './createNullCache';

package/src/constants.ts

@@ -1,7 +0,0 @@
-export const DEFAULT_CONNECT_TIMEOUT_BROWSER = 1000;
-export const DEFAULT_READ_TIMEOUT_BROWSER = 2000;
-export const DEFAULT_WRITE_TIMEOUT_BROWSER = 30000;
-
-export const DEFAULT_CONNECT_TIMEOUT_NODE = 2000;
-export const DEFAULT_READ_TIMEOUT_NODE = 5000;
-export const DEFAULT_WRITE_TIMEOUT_NODE = 30000;

package/src/createAlgoliaAgent.ts

@@ -1,18 +0,0 @@
-import type { AlgoliaAgent, AlgoliaAgentOptions } from './types';
-
-export function createAlgoliaAgent(version: string): AlgoliaAgent {
-  const algoliaAgent = {
-    value: `Algolia for JavaScript (${version})`,
-    add(options: AlgoliaAgentOptions): AlgoliaAgent {
-      const addedAlgoliaAgent = `; ${options.segment}${options.version !== undefined ? ` (${options.version})` : ''}`;
-
-      if (algoliaAgent.value.indexOf(addedAlgoliaAgent) === -1) {
-        algoliaAgent.value = `${algoliaAgent.value}${addedAlgoliaAgent}`;
-      }
-
-      return algoliaAgent;
-    },
-  };
-
-  return algoliaAgent;
-}

package/src/createAuth.ts

@@ -1,25 +0,0 @@
-import type { AuthMode, Headers, QueryParameters } from './types';
-
-export function createAuth(
-  appId: string,
-  apiKey: string,
-  authMode: AuthMode = 'WithinHeaders',
-): {
-  readonly headers: () => Headers;
-  readonly queryParameters: () => QueryParameters;
-} {
-  const credentials = {
-    'x-algolia-api-key': apiKey,
-    'x-algolia-application-id': appId,
-  };
-
-  return {
-    headers(): Headers {
-      return authMode === 'WithinHeaders' ? credentials : {};
-    },
-
-    queryParameters(): QueryParameters {
-      return authMode === 'WithinQueryParameters' ? credentials : {};
-    },
-  };
-}

package/src/createIterablePromise.ts

@@ -1,47 +0,0 @@
-import type { CreateIterablePromise } from './types/createIterablePromise';
-
-/**
- * Helper: Returns the promise of a given `func` to iterate on, based on a given `validate` condition.
- *
- * @param createIterator - The createIterator options.
- * @param createIterator.func - The function to run, which returns a promise.
- * @param createIterator.validate - The validator function. It receives the resolved return of `func`.
- * @param createIterator.aggregator - The function that runs right after the `func` method has been executed, allows you to do anything with the response before `validate`.
- * @param createIterator.error - The `validate` condition to throw an error, and its message.
- * @param createIterator.timeout - The function to decide how long to wait between iterations.
- */
-export function createIterablePromise<TResponse>({
-  func,
-  validate,
-  aggregator,
-  error,
-  timeout = (): number => 0,
-}: CreateIterablePromise<TResponse>): Promise<TResponse> {
-  const retry = (previousResponse?: TResponse): Promise<TResponse> => {
-    return new Promise<TResponse>((resolve, reject) => {
-      func(previousResponse)
-        .then((response) => {
-          if (aggregator) {
-            aggregator(response);
-          }
-
-          if (validate(response)) {
-            return resolve(response);
-          }
-
-          if (error && error.validate(response)) {
-            return reject(new Error(error.message(response)));
-          }
-
-          return setTimeout(() => {
-            retry(response).then(resolve).catch(reject);
-          }, timeout());
-        })
-        .catch((err) => {
-          reject(err);
-        });
-    });
-  };
-
-  return retry();
-}

package/src/getAlgoliaAgent.ts

@@ -1,19 +0,0 @@
-import { createAlgoliaAgent } from './createAlgoliaAgent';
-import type { AlgoliaAgent, AlgoliaAgentOptions } from './types';
-
-export type GetAlgoliaAgent = {
-  algoliaAgents: AlgoliaAgentOptions[];
-  client: string;
-  version: string;
-};
-
-export function getAlgoliaAgent({ algoliaAgents, client, version }: GetAlgoliaAgent): AlgoliaAgent {
-  const defaultAlgoliaAgent = createAlgoliaAgent(version).add({
-    segment: client,
-    version,
-  });
-
-  algoliaAgents.forEach((algoliaAgent) => defaultAlgoliaAgent.add(algoliaAgent));
-
-  return defaultAlgoliaAgent;
-}

package/src/logger/createNullLogger.ts

@@ -1,15 +0,0 @@
-import type { Logger } from '../types/logger';
-
-export function createNullLogger(): Logger {
-  return {
-    debug(_message: string, _args?: any): Promise<void> {
-      return Promise.resolve();
-    },
-    info(_message: string, _args?: any): Promise<void> {
-      return Promise.resolve();
-    },
-    error(_message: string, _args?: any): Promise<void> {
-      return Promise.resolve();
-    },
-  };
-}

package/src/logger/index.ts

@@ -1 +0,0 @@
-export * from './createNullLogger';

package/src/transporter/createStatefulHost.ts

@@ -1,19 +0,0 @@
-import type { Host, StatefulHost } from '../types';
-
-// By default, API Clients at Algolia have expiration delay of 5 mins.
-// In the JavaScript client, we have 2 mins.
-const EXPIRATION_DELAY = 2 * 60 * 1000;
-
-export function createStatefulHost(host: Host, status: StatefulHost['status'] = 'up'): StatefulHost {
-  const lastUpdate = Date.now();
-
-  function isUp(): boolean {
-    return status === 'up' || Date.now() - lastUpdate > EXPIRATION_DELAY;
-  }
-
-  function isTimedOut(): boolean {
-    return status === 'timed out' && Date.now() - lastUpdate <= EXPIRATION_DELAY;
-  }
-
-  return { ...host, status, lastUpdate, isUp, isTimedOut };
-}