@algolia/client-common 4.14.2 → 5.0.0-alpha.11

package/package.json

@@ -1,22 +1,32 @@
 {
   "name": "@algolia/client-common",
-  "version": "4.14.2",
-  "private": false,
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/algolia/algoliasearch-client-javascript.git"
-  },
+  "version": "5.0.0-alpha.11",
+  "description": "Common package for the Algolia JavaScript API client.",
+  "repository": "algolia/algoliasearch-client-javascript",
   "license": "MIT",
-  "sideEffects": false,
-  "main": "index.js",
-  "module": "dist/client-common.esm.js",
-  "types": "dist/client-common.d.ts",
+  "author": "Algolia",
+  "main": "dist/client-common.cjs.js",
+  "module": "dist/client-common.esm.node.js",
+  "types": "dist/index.d.ts",
   "files": [
-    "index.js",
-    "dist"
+    "dist",
+    "src",
+    "index.ts"
   ],
-  "dependencies": {
-    "@algolia/requester-common": "4.14.2",
-    "@algolia/transporter": "4.14.2"
+  "scripts": {
+    "build": "yarn clean && rollup --config",
+    "clean": "rm -rf ./dist || true",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@types/jest": "28.1.7",
+    "@types/node": "16.11.47",
+    "jest": "28.1.3",
+    "jest-environment-jsdom": "28.1.3",
+    "ts-jest": "28.0.8",
+    "typescript": "4.7.4"
+  },
+  "engines": {
+    "node": ">= 14.0.0"
   }
 }

package/src/__tests__/cache/browser-local-storage-cache.test.ts

@@ -0,0 +1,134 @@
+import { createBrowserLocalStorageCache } from '../../cache';
+
+const version = 'foobar';
+const notAvailableStorage = new Proxy(window.localStorage, {
+  get() {
+    return (): void => {
+      throw new Error('Component is not available');
+    };
+  },
+});
+
+type DefaultValue = Promise<{ bar: number }>;
+
+describe('browser local storage cache', () => {
+  const missMock = jest.fn();
+  const events = {
+    miss: (): Promise<any> => Promise.resolve(missMock()),
+  };
+
+  beforeEach(() => {
+    window.localStorage.clear();
+    jest.clearAllMocks();
+  });
+
+  it('sets/gets values', async () => {
+    const cache = createBrowserLocalStorageCache({ key: version });
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 1 });
+
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      { bar: 1 }
+    );
+    expect(missMock.mock.calls.length).toBe(1);
+
+    await cache.set({ key: 'foo' }, { foo: 2 });
+
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      { foo: 2 }
+    );
+    expect(missMock.mock.calls.length).toBe(1);
+  });
+
+  it('deletes keys', async () => {
+    const cache = createBrowserLocalStorageCache({ key: version });
+
+    await cache.set({ key: 'foo' }, { bar: 1 });
+    await cache.delete({ key: 'foo' });
+
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 2 });
+
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      { bar: 2 }
+    );
+    expect(missMock.mock.calls.length).toBe(1);
+  });
+
+  it('can be cleared', async () => {
+    const cache = createBrowserLocalStorageCache({ key: version });
+
+    await cache.set({ key: 'foo' }, { bar: 1 });
+    await cache.clear();
+
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 2 });
+
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      { bar: 2 }
+    );
+    expect(missMock.mock.calls.length).toBe(1);
+    expect(localStorage.length).toBe(0);
+  });
+
+  it('do throws localstorage exceptions on access', async () => {
+    const message =
+      "Failed to read the 'localStorage' property from 'Window': Access is denied for this document.";
+    const cache = createBrowserLocalStorageCache(
+      new Proxy(
+        { key: 'foo' },
+        {
+          get(_, key): DOMException | string {
+            if (key === 'key') {
+              return 'foo';
+            }
+
+            // Simulates a window.localStorage access.
+            throw new DOMException(message);
+          },
+        }
+      )
+    );
+    const key = { foo: 'bar' };
+    const value = 'foo';
+    const fallback = 'bar';
+
+    await expect(cache.delete(key)).rejects.toEqual(new DOMException(message));
+    await expect(cache.set(key, value)).rejects.toEqual(
+      new DOMException(message)
+    );
+    await expect(
+      cache.get(key, () => Promise.resolve(fallback))
+    ).rejects.toEqual(new DOMException(message));
+  });
+
+  it('do throws localstorage exceptions after access', async () => {
+    const cache = createBrowserLocalStorageCache({
+      key: version,
+      localStorage: notAvailableStorage,
+    });
+    const key = { foo: 'bar' };
+    const value = 'foo';
+    const fallback = 'bar';
+    const message = 'Component is not available';
+
+    await expect(cache.delete(key)).rejects.toEqual(new Error(message));
+    await expect(cache.set(key, value)).rejects.toEqual(new Error(message));
+    await expect(
+      cache.get(key, () => Promise.resolve(fallback))
+    ).rejects.toEqual(new Error(message));
+  });
+
+  it('creates a namespace within local storage', async () => {
+    const cache = createBrowserLocalStorageCache({
+      key: version,
+    });
+    const key = { foo: 'bar' };
+    const value = 'foo';
+
+    expect(localStorage.getItem(`algolia-client-js-${version}`)).toBeNull();
+
+    await cache.set(key, value);
+
+    expect(localStorage.getItem(`algolia-client-js-${version}`)).toBe(
+      '{"{\\"foo\\":\\"bar\\"}":"foo"}'
+    );
+  });
+});

package/src/__tests__/cache/fallbackable-cache.test.ts

@@ -0,0 +1,126 @@
+import {
+  createBrowserLocalStorageCache,
+  createFallbackableCache,
+  createMemoryCache,
+  createNullCache,
+} from '../../cache';
+
+const version = 'foobar';
+const notAvailableStorage = new Proxy(window.localStorage, {
+  get() {
+    return (): void => {
+      throw new Error('Component is not available');
+    };
+  },
+});
+
+type DefaultValue = Promise<Record<number, number>>;
+
+describe('fallbackable cache', () => {
+  const key = { 1: 2 };
+  const value = { 3: 4 };
+  const defaultValue = (): DefaultValue => Promise.resolve({ 5: 6 });
+
+  it('always fallback in null cache', async () => {
+    const cache = createFallbackableCache({ caches: [] });
+
+    await cache.set(key, value);
+    expect(await cache.get(key, defaultValue)).toEqual({
+      5: 6,
+    });
+  });
+
+  describe('order', () => {
+    it('use memory cache', async () => {
+      const cache = createFallbackableCache({
+        caches: [createMemoryCache()],
+      });
+
+      await cache.set(key, value);
+
+      expect(await cache.get(key, defaultValue)).toEqual({
+        3: 4,
+      });
+    });
+
+    it('use null cache first', async () => {
+      const cache = createFallbackableCache({
+        caches: [createNullCache(), createMemoryCache()],
+      });
+
+      await cache.set(key, value);
+
+      expect(await cache.get(key, defaultValue)).toEqual({
+        5: 6,
+      });
+    });
+  });
+
+  describe('fallbacks', () => {
+    it('to memory cache', async () => {
+      const cache = createFallbackableCache({
+        caches: [
+          createBrowserLocalStorageCache({
+            key: version,
+            // @ts-expect-error this will make the cache fail, and normally we fallback on memory cache
+            localStorage: {},
+          }),
+          createMemoryCache(),
+        ],
+      });
+
+      await cache.set(key, value);
+
+      expect(await cache.get(key, defaultValue)).toEqual({
+        3: 4,
+      });
+    });
+
+    it('to null cache', async () => {
+      const cache = createFallbackableCache({
+        caches: [
+          createBrowserLocalStorageCache({
+            key: version,
+            // @ts-expect-error this will make the cache fail, and normally we fallback on memory cache
+            localStorage: {},
+          }),
+        ],
+      });
+
+      await cache.set(key, value);
+
+      expect(await cache.get(key, defaultValue)).toEqual({
+        5: 6,
+      });
+    });
+
+    it('to memory cache', async () => {
+      const cache = createFallbackableCache({
+        caches: [
+          createBrowserLocalStorageCache({
+            key: version,
+            // @ts-expect-error this will make the cache fail
+            localStorage: {},
+          }),
+          createBrowserLocalStorageCache({
+            key: version,
+            localStorage: notAvailableStorage, // this will make the cache fail due localStorage not available
+          }),
+          createMemoryCache(),
+        ],
+      });
+
+      await cache.set(key, value);
+
+      expect(await cache.get(key, defaultValue)).toEqual({
+        3: 4,
+      });
+
+      await cache.clear();
+
+      expect(await cache.get(key, defaultValue)).toEqual({
+        5: 6,
+      });
+    });
+  });
+});

package/src/__tests__/cache/memory-cache.test.ts

@@ -0,0 +1,90 @@
+import { createMemoryCache } from '../../cache';
+
+type DefaultValue = Promise<{ bar: number }>;
+
+describe('memory cache', () => {
+  const missMock = jest.fn();
+  const events = {
+    miss: (): Promise<any> => Promise.resolve(missMock()),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('sets/gets values', async () => {
+    const cache = createMemoryCache();
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 1 });
+
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      {
+        bar: 1,
+      }
+    );
+
+    await cache.set({ key: 'foo' }, { foo: 2 });
+
+    expect(missMock.mock.calls.length).toBe(1);
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      { foo: 2 }
+    );
+    expect(missMock.mock.calls.length).toBe(1);
+  });
+
+  it('getted values do not have references to the value on cache', async () => {
+    const cache = createMemoryCache();
+    const key = { foo: 'bar' };
+    const obj = { 1: { 2: 'bar' } };
+    const defaultObj = { 1: { 2: 'too' } };
+
+    await cache.set(key, obj);
+    const gettedValue = await cache.get(key, () => Promise.resolve(defaultObj));
+    gettedValue[1][2] = 'foo';
+
+    expect(await cache.get(key, () => Promise.resolve(defaultObj))).toEqual({
+      1: { 2: 'bar' },
+    });
+  });
+
+  it('deletes keys', async () => {
+    const cache = createMemoryCache();
+
+    await cache.set({ key: 'foo' }, { bar: 1 });
+    await cache.delete({ key: 'foo' });
+
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 2 });
+
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      { bar: 2 }
+    );
+    expect(missMock.mock.calls.length).toBe(1);
+  });
+
+  it('can be cleared', async () => {
+    const cache = createMemoryCache();
+
+    await cache.set({ key: 'foo' }, { bar: 1 });
+    await cache.clear();
+
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 2 });
+
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      { bar: 2 }
+    );
+    expect(missMock.mock.calls.length).toBe(1);
+  });
+
+  it('do not force promise based api for clearing cache', async () => {
+    const cache = createMemoryCache();
+
+    cache.set({ key: 'foo' }, { bar: 1 });
+    cache.clear();
+
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 2 });
+
+    expect(await cache.get({ key: 'foo' }, defaultValue, events)).toMatchObject(
+      { bar: 2 }
+    );
+    expect(missMock.mock.calls.length).toBe(1);
+  });
+});

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

@@ -0,0 +1,49 @@
+import { createNullCache } from '../../cache';
+
+type DefaultValue = Promise<{ bar: number }>;
+
+describe('null cache', () => {
+  const cache = createNullCache();
+  const missMock = jest.fn();
+  const events = {
+    miss: (): Promise<any> => Promise.resolve(missMock()),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('does not set value', async () => {
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 12 });
+
+    await cache.set({ key: 'key' }, { foo: 10 });
+
+    expect(await cache.get({ key: 'key' }, defaultValue, events)).toMatchObject(
+      {
+        bar: 12,
+      }
+    );
+
+    expect(missMock.mock.calls.length).toBe(1);
+  });
+
+  it('returns default value', async () => {
+    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 12 });
+
+    expect(await cache.get({ foo: 'foo' }, defaultValue, events)).toMatchObject(
+      {
+        bar: 12,
+      }
+    );
+
+    expect(missMock.mock.calls.length).toBe(1);
+  });
+
+  it('can be deleted', async () => {
+    await cache.delete('foo');
+  });
+
+  it('can be cleared', async () => {
+    await cache.clear();
+  });
+});

package/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).toBeLessThanOrEqual(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).toBeLessThanOrEqual(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);
+    });
+  });
+});