@algolia/client-common 4.14.1 → 5.0.0-alpha.10

package/src/types/host.ts

@@ -0,0 +1,38 @@
+export type Host = {
+  /**
+   * The host URL.
+   */
+  url: string;
+
+  /**
+   * The accepted transporter.
+   */
+  accept: 'read' | 'readWrite' | 'write';
+
+  /**
+   * The protocol of the host URL.
+   */
+  protocol: 'http' | 'https';
+};
+
+export type StatefulHost = Host & {
+  /**
+   * The status of the host.
+   */
+  status: 'down' | 'timed out' | 'up';
+
+  /**
+   * The last update of the host status, used to compare with the expiration delay.
+   */
+  lastUpdate: number;
+
+  /**
+   * Returns whether the host is up or not.
+   */
+  isUp: () => boolean;
+
+  /**
+   * Returns whether the host is timed out or not.
+   */
+  isTimedOut: () => boolean;
+};

package/src/types/index.ts

@@ -0,0 +1,6 @@
+export * from './cache';
+export * from './createClient';
+export * from './createIterablePromise';
+export * from './host';
+export * from './requester';
+export * from './transporter';

package/src/types/requester.ts

@@ -0,0 +1,72 @@
+import type { Headers, QueryParameters } from './transporter';
+
+/**
+ * The method of the request.
+ */
+export type Method = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+
+export type Request = {
+  method: Method;
+  /**
+   * The path of the REST API to send the request to.
+   */
+  path: string;
+  queryParameters: QueryParameters;
+  data?: Array<Record<string, any>> | Record<string, any>;
+  headers: Headers;
+  /**
+   * If the given request should persist on the cache. Keep in mind,
+   * that some methods may have this option enabled by default.
+   */
+  cacheable?: boolean;
+  /**
+   * Some POST methods in the Algolia REST API uses the `read` transporter.
+   * This information is defined at the spec level.
+   */
+  useReadTransporter?: boolean;
+};
+
+export type EndRequest = Pick<Request, 'headers' | 'method'> & {
+  /**
+   * The full URL of the REST API.
+   */
+  url: string;
+  /**
+   * The connection timeout, in milliseconds.
+   */
+  connectTimeout: number;
+  /**
+   * The response timeout, in milliseconds.
+   */
+  responseTimeout: number;
+  data?: string;
+};
+
+export type Response = {
+  /**
+   * The body of the response.
+   */
+  content: string;
+  /**
+   * Whether the API call is timed out or not.
+   */
+  isTimedOut: boolean;
+  /**
+   * The HTTP status code of the response.
+   */
+  status: number;
+};
+
+export type Requester = {
+  /**
+   * Sends the given `request` to the server.
+   */
+  send: (request: EndRequest) => Promise<Response>;
+};
+
+export type EchoResponse = Omit<EndRequest, 'data'> &
+  Pick<Request, 'data' | 'path'> & {
+    host: string;
+    algoliaAgent: string;
+    searchParams?: Record<string, string>;
+  };

package/src/types/transporter.ts

@@ -0,0 +1,153 @@
+import type { Cache } from './cache';
+import type { Host } from './host';
+import type { Request, Requester, EndRequest, Response } from './requester';
+
+export type Headers = Record<string, string>;
+export type QueryParameters = Record<string, any>;
+
+export type RequestOptions = Pick<Request, 'cacheable'> & {
+  /**
+   * Custom timeout for the request. Note that, in normal situations
+   * the given timeout will be applied. But the transporter layer may
+   * increase this timeout if there is need for it.
+   */
+  timeout?: number;
+
+  /**
+   * Custom headers for the request. This headers are
+   * going to be merged the transporter headers.
+   */
+  headers?: Headers;
+
+  /**
+   * Custom query parameters for the request. This query parameters are
+   * going to be merged the transporter query parameters.
+   */
+  queryParameters?: QueryParameters;
+
+  /**
+   * Custom data for the request. This data is
+   * going to be merged the transporter data.
+   */
+  data?: Array<Record<string, any>> | Record<string, any>;
+};
+
+export type StackFrame = {
+  request: EndRequest;
+  response: Response;
+  host: Host;
+  triesLeft: number;
+};
+
+export type AlgoliaAgentOptions = {
+  /**
+   * The segment. Usually the integration name.
+   */
+  segment: string;
+
+  /**
+   * The version. Usually the integration version.
+   */
+  version?: string;
+};
+
+export type AlgoliaAgent = {
+  /**
+   * The raw value of the user agent.
+   */
+  value: string;
+
+  /**
+   * Mutates the current user agent adding the given user agent options.
+   */
+  add: (options: AlgoliaAgentOptions) => AlgoliaAgent;
+};
+
+export type Timeouts = {
+  /**
+   * Timeout in milliseconds before the connection is established.
+   */
+  connect: number;
+
+  /**
+   * Timeout in milliseconds before reading the response on a read request.
+   */
+  read: number;
+
+  /**
+   * Timeout in milliseconds before reading the response on a write request.
+   */
+  write: number;
+};
+
+export type TransporterOptions = {
+  /**
+   * The cache of the hosts. Usually used to persist
+   * the state of the host when its down.
+   */
+  hostsCache: Cache;
+
+  /**
+   * The underlying requester used. Should differ
+   * depending of the environment where the client
+   * will be used.
+   */
+  requester: Requester;
+
+  /**
+   * The cache of the requests. When requests are
+   * `cacheable`, the returned promised persists
+   * in this cache to shared in similar requests
+   * before being resolved.
+   */
+  requestsCache: Cache;
+
+  /**
+   * The cache of the responses. When requests are
+   * `cacheable`, the returned responses persists
+   * in this cache to shared in similar requests.
+   */
+  responsesCache: Cache;
+
+  /**
+   * The timeouts used by the requester. The transporter
+   * layer may increase this timeouts as defined on the
+   * retry strategy.
+   */
+  timeouts: Timeouts;
+
+  /**
+   * The hosts used by the requester.
+   */
+  hosts: Host[];
+
+  /**
+   * The headers used by the requester. The transporter
+   * layer may add some extra headers during the request
+   * for the user agent, and others.
+   */
+  baseHeaders: Headers;
+
+  /**
+   * The query parameters used by the requester. The transporter
+   * layer may add some extra headers during the request
+   * for the user agent, and others.
+   */
+  baseQueryParameters: QueryParameters;
+
+  /**
+   * The user agent used. Sent on query parameters.
+   */
+  algoliaAgent: AlgoliaAgent;
+};
+
+export type Transporter = TransporterOptions & {
+  /**
+   * Performs a request.
+   * The `baseRequest` and `baseRequestOptions` will be merged accordingly.
+   */
+  request: <TResponse>(
+    baseRequest: Request,
+    baseRequestOptions?: RequestOptions
+  ) => Promise<TResponse>;
+};

package/dist/client-common.d.ts

@@ -1,102 +0,0 @@
-import { Headers } from '@algolia/transporter';
-import { HostOptions } from '@algolia/transporter';
-import { QueryParameters } from '@algolia/transporter';
-import { RequestOptions } from '@algolia/transporter';
-import { Transporter } from '@algolia/transporter';
-import { TransporterOptions } from '@algolia/transporter';
-
-declare type AddedMethods<TBase, TMethods extends Methods<TBase>> = TBase & {
-    [TKey in keyof TMethods extends string ? keyof TMethods : never]: ReturnType<TMethods[TKey]>;
-};
-
-export declare function addMethods<TBase extends {}, TMethods extends Methods<TBase>>(base: TBase, methods?: TMethods): AddedMethods<TBase, TMethods>;
-
-export declare type Auth = {
-    /**
-     * Returns the headers related to auth. Should be
-     * merged to the transporter headers.
-     */
-    readonly headers: () => Readonly<Record<string, string>>;
-    /**
-     * Returns the query parameters related to auth. Should be
-     * merged to the query parameters headers.
-     */
-    readonly queryParameters: () => Readonly<Record<string, string>>;
-};
-
-export declare const AuthMode: Readonly<Record<string, AuthModeType>>;
-
-export declare type AuthModeType = 0 | 1;
-
-export declare type ClientTransporterOptions = Pick<TransporterOptions, Exclude<keyof TransporterOptions, 'headers'> & Exclude<keyof TransporterOptions, 'queryParameters'> & Exclude<keyof TransporterOptions, 'hosts'>> & {
-    /**
-     * The hosts used by the requester.
-     */
-    readonly hosts?: readonly HostOptions[];
-    /**
-     * The headers used by the requester. The transporter
-     * layer may add some extra headers during the request
-     * for the user agent, and others.
-     */
-    readonly headers?: Headers;
-    /**
-     * The query parameters used by the requester. The transporter
-     * layer may add some extra headers during the request
-     * for the user agent, and others.
-     */
-    readonly queryParameters?: QueryParameters;
-};
-
-export declare function createAuth(authMode: AuthModeType, appId: string, apiKey: string): Auth;
-
-export declare type CreateClient<TClient, TOptions> = <TMethods extends {
-    readonly [key: string]: (base: TClient) => (...args: any) => any;
-}>(options: TOptions & {
-    readonly methods?: TMethods;
-}) => TClient & {
-    [key in keyof TMethods extends string ? keyof TMethods : never]: ReturnType<TMethods[key]>;
-};
-
-export declare function createRetryablePromise<TResponse>(callback: (retry: () => Promise<TResponse>) => Promise<TResponse>): Promise<TResponse>;
-
-export declare function createWaitablePromise<TResponse>(promise: Readonly<Promise<TResponse>>, wait?: Wait<TResponse>): Readonly<WaitablePromise<TResponse>>;
-
-export declare const destroy: (base: {
-    readonly transporter: Transporter;
-}) => () => Readonly<Promise<void>>;
-
-export declare function encode(format: string, ...args: readonly any[]): string;
-
-declare type Methods<TBase> = {
-    readonly [key: string]: (base: TBase) => (...args: any[]) => any;
-};
-
-export declare function shuffle<TData>(array: TData[]): TData[];
-
-export declare const version = "4.14.1";
-
-export declare type Wait<TResponse> = (
-/**
- * The original response.
- */
-response: TResponse, 
-/**
- * The custom request options.
- */
-requestOptions?: RequestOptions) => Readonly<Promise<any>>;
-
-export declare type WaitablePromise<TResponse> = Readonly<Promise<TResponse>> & {
-    /**
-     * Wait for a task to complete before executing the next line of code, to synchronize index updates.
-     *
-     * All write operations in Algolia are asynchronous by design. It means that when you add or
-     * update an object to your index, our servers will reply to your request with a taskID as
-     * soon as they understood the write operation. The actual insert and indexing will be
-     * done after replying to your code.
-     *
-     * You can wait for a task to complete by using this method.
-     */
-    readonly wait: (requestOptions?: RequestOptions) => Readonly<WaitablePromise<TResponse>>;
-};
-
-export { }

package/dist/client-common.esm.js

@@ -1,89 +0,0 @@
-function createAuth(authMode, appId, apiKey) {
-    const credentials = {
-        'x-algolia-api-key': apiKey,
-        'x-algolia-application-id': appId,
-    };
-    return {
-        headers() {
-            return authMode === AuthMode.WithinHeaders ? credentials : {};
-        },
-        queryParameters() {
-            return authMode === AuthMode.WithinQueryParameters ? credentials : {};
-        },
-    };
-}
-
-function createRetryablePromise(callback) {
-    let retriesCount = 0; // eslint-disable-line functional/no-let
-    const retry = () => {
-        retriesCount++;
-        return new Promise((resolve) => {
-            setTimeout(() => {
-                resolve(callback(retry));
-            }, Math.min(100 * retriesCount, 1000));
-        });
-    };
-    return callback(retry);
-}
-
-function createWaitablePromise(promise, wait = (_response, _requestOptions) => {
-    return Promise.resolve();
-}) {
-    // eslint-disable-next-line functional/immutable-data
-    return Object.assign(promise, {
-        wait(requestOptions) {
-            return createWaitablePromise(promise
-                .then(response => Promise.all([wait(response, requestOptions), response]))
-                .then(promiseResults => promiseResults[1]));
-        },
-    });
-}
-
-// eslint-disable-next-line functional/prefer-readonly-type
-function shuffle(array) {
-    let c = array.length - 1; // eslint-disable-line functional/no-let
-    // eslint-disable-next-line functional/no-loop-statement
-    for (c; c > 0; c--) {
-        const b = Math.floor(Math.random() * (c + 1));
-        const a = array[c];
-        array[c] = array[b]; // eslint-disable-line functional/immutable-data, no-param-reassign
-        array[b] = a; // eslint-disable-line functional/immutable-data, no-param-reassign
-    }
-    return array;
-}
-function addMethods(base, methods) {
-    if (!methods) {
-        return base;
-    }
-    Object.keys(methods).forEach(key => {
-        // eslint-disable-next-line functional/immutable-data, no-param-reassign
-        base[key] = methods[key](base);
-    });
-    return base;
-}
-function encode(format, ...args) {
-    // eslint-disable-next-line functional/no-let
-    let i = 0;
-    return format.replace(/%s/g, () => encodeURIComponent(args[i++]));
-}
-
-const version = '4.14.1';
-
-const destroy = (base) => {
-    return () => {
-        return base.transporter.requester.destroy();
-    };
-};
-
-const AuthMode = {
-    /**
-     * If auth credentials should be in query parameters.
-     */
-    WithinQueryParameters: 0,
-    /**
-     * If auth credentials should be in headers.
-     */
-    WithinHeaders: 1,
-};
-
-export { AuthMode, addMethods, createAuth, createRetryablePromise, createWaitablePromise, destroy, encode, shuffle, version };

package/index.js

@@ -1,2 +0,0 @@
-// eslint-disable-next-line functional/immutable-data, import/no-commonjs
-module.exports = require('./dist/client-common.cjs.js');