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

package/src/cache/createBrowserLocalStorageCache.ts

@@ -0,0 +1,74 @@
+import type { 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) || '{}');
+  }
+
+  return {
+    get<TValue>(
+      key: Record<string, any> | string,
+      defaultValue: () => Promise<TValue>,
+      events: CacheEvents<TValue> = {
+        miss: (): Promise<void> => Promise.resolve(),
+      }
+    ): Promise<TValue> {
+      return Promise.resolve()
+        .then(() => {
+          const keyAsString = JSON.stringify(key);
+          const value = getNamespace<TValue>()[keyAsString];
+
+          return Promise.all([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)] = 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

@@ -0,0 +1,53 @@
+import type { FallbackableCacheOptions, Cache, CacheEvents } 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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,34 @@
+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

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

package/src/constants.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,20 @@
+import type { AlgoliaAgentOptions, AlgoliaAgent } 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

@@ -0,0 +1,25 @@
+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/createEchoRequester.ts

@@ -0,0 +1,59 @@
+import type { EchoResponse, EndRequest, Requester, Response } from './types';
+
+export type EchoRequesterParams = {
+  getURL: (url: string) => URL;
+  status?: number;
+};
+
+function getUrlParams({
+  host,
+  searchParams: urlSearchParams,
+  pathname,
+}: URL): Pick<EchoResponse, 'algoliaAgent' | 'host' | 'path' | 'searchParams'> {
+  const algoliaAgent = urlSearchParams.get('x-algolia-agent') || '';
+  const searchParams = {};
+
+  for (const [k, v] of urlSearchParams) {
+    if (k === 'x-algolia-agent') {
+      continue;
+    }
+
+    searchParams[k] = v;
+  }
+
+  return {
+    host,
+    algoliaAgent,
+    searchParams:
+      Object.keys(searchParams).length === 0 ? undefined : searchParams,
+    path: pathname,
+  };
+}
+
+export function createEchoRequester({
+  getURL,
+  status = 200,
+}: EchoRequesterParams): Requester {
+  function send(request: EndRequest): Promise<Response> {
+    const { host, searchParams, algoliaAgent, path } = getUrlParams(
+      getURL(request.url)
+    );
+
+    const content: EchoResponse = {
+      ...request,
+      data: request.data ? JSON.parse(request.data) : undefined,
+      path,
+      host,
+      algoliaAgent: encodeURI(algoliaAgent),
+      searchParams,
+    };
+
+    return Promise.resolve({
+      content: JSON.stringify(content),
+      isTimedOut: false,
+      status,
+    });
+  }
+
+  return { send };
+}

package/src/createIterablePromise.ts

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,25 @@
+import { createAlgoliaAgent } from './createAlgoliaAgent';
+import type { AlgoliaAgentOptions, AlgoliaAgent } 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/transporter/createStatefulHost.ts

@@ -0,0 +1,24 @@
+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 };
+}