@algolia/client-common 5.8.1 → 5.9.1

package/index.d.ts

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

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./dist/common.cjs');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/client-common",
-  "version": "5.8.1",
+  "version": "5.9.1",
   "description": "Common package for the Algolia JavaScript API client.",
   "repository": {
     "type": "git",
@@ -11,8 +11,8 @@
   "type": "module",
   "files": [
     "dist",
-    "src",
-    "index.ts"
+    "index.js",
+    "index.d.ts"
   ],
   "exports": {
     ".": {
@@ -35,12 +35,12 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.16.4",
-    "@types/node": "22.7.4",
+    "@types/node": "22.7.5",
     "jsdom": "25.0.1",
     "publint": "0.2.11",
     "ts-node": "10.9.2",
     "tsup": "8.3.0",
-    "typescript": "5.6.2",
+    "typescript": "5.6.3",
     "vitest": "2.1.2"
   },
   "engines": {

package/index.ts

@@ -1,9 +0,0 @@
-export * from './src/cache';
-export * from './src/constants';
-export * from './src/createAlgoliaAgent';
-export * from './src/createAuth';
-export * from './src/createIterablePromise';
-export * from './src/getAlgoliaAgent';
-export * from './src/logger';
-export * from './src/transporter';
-export * from './src/types';

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

@@ -1,171 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-
-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 = vi.fn();
-  const events = {
-    miss: (): Promise<any> => Promise.resolve(missMock()),
-  };
-
-  beforeEach(() => {
-    window.localStorage.clear();
-    vi.clearAllMocks();
-  });
-
-  test('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);
-  });
-
-  test('reads unexpired timeToLive keys', async () => {
-    const cache = createBrowserLocalStorageCache({
-      key: version,
-      timeToLive: 5,
-    });
-    await cache.set({ key: 'foo' }, { bar: 1 });
-
-    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 2 });
-
-    expect(
-      await cache.get({ key: 'foo' }, defaultValue, {
-        miss: () => Promise.resolve(missMock()),
-      }),
-    ).toMatchObject({ bar: 1 });
-
-    expect(missMock.mock.calls.length).toBe(0);
-  });
-
-  test('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);
-  });
-
-  test('deletes expired keys', async () => {
-    const cache = createBrowserLocalStorageCache({
-      key: version,
-      timeToLive: -1,
-    });
-    await cache.set({ key: 'foo' }, { bar: 1 });
-
-    const defaultValue = (): DefaultValue => Promise.resolve({ bar: 2 });
-
-    expect(
-      await cache.get({ key: 'foo' }, defaultValue, {
-        miss: () => Promise.resolve(missMock()),
-      }),
-    ).toMatchObject({ bar: 2 });
-
-    expect(missMock.mock.calls.length).toBe(1);
-  });
-
-  test('can be cleared', async () => {
-    const cache = createBrowserLocalStorageCache({ key: version });
-    await cache.set({ key: 'foo' }, { bar: 1 });
-
-    await cache.clear();
-
-    const defaultValue = (): Promise<void> => Promise.resolve({ bar: 2 });
-
-    expect(localStorage.length).toBe(0);
-
-    expect(
-      await cache.get({ key: 'foo' }, defaultValue, {
-        miss: () => Promise.resolve(missMock()),
-      }),
-    ).toMatchObject({ bar: 2 });
-
-    expect(missMock.mock.calls.length).toBe(1);
-
-    expect(localStorage.getItem(`algolia-client-js-${version}`)).toEqual('{}');
-  });
-
-  test('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));
-  });
-
-  test('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));
-  });
-
-  test('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);
-
-    const expectedValue = expect.objectContaining({
-      [JSON.stringify(key)]: {
-        timestamp: expect.any(Number),
-        value,
-      },
-    });
-
-    const localStorageValue = localStorage.getItem(`algolia-client-js-${version}`);
-
-    expect(JSON.parse(localStorageValue ? localStorageValue : '{}')).toEqual(expectedValue);
-  });
-});

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

@@ -1,126 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-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 });
-
-  test('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', () => {
-    test('use memory cache', async () => {
-      const cache = createFallbackableCache({
-        caches: [createMemoryCache()],
-      });
-
-      await cache.set(key, value);
-
-      expect(await cache.get(key, defaultValue)).toEqual({
-        3: 4,
-      });
-    });
-
-    test('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,
-      });
-    });
-  });
-
-  test('fallback to 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,
-    });
-  });
-
-  test('fallback 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,
-    });
-  });
-
-  test('fallback 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

@@ -1,82 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-
-import { createMemoryCache } from '../../cache';
-
-type DefaultValue = Promise<{ bar: number }>;
-
-describe('memory cache', () => {
-  const missMock = vi.fn();
-  const events = {
-    miss: (): Promise<any> => Promise.resolve(missMock()),
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test('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);
-  });
-
-  test('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' },
-    });
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('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

@@ -1,47 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-
-import { createNullCache } from '../../cache';
-
-type DefaultValue = Promise<{ bar: number }>;
-
-describe('null cache', () => {
-  const cache = createNullCache();
-  const missMock = vi.fn();
-  const events = {
-    miss: (): Promise<any> => Promise.resolve(missMock()),
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('can be deleted', () => {
-    expect(async () => await cache.delete('foo')).not.toThrowError();
-  });
-
-  test('can be cleared', () => {
-    expect(async () => await cache.clear()).not.toThrowError();
-  });
-});