@whereby.com/browser-sdk 2.0.0-alpha → 2.0.0-alpha1

package/src/lib/api/ApiClient.ts

@@ -1,111 +0,0 @@
-import assert from "assert";
-import nodeBtoa from "btoa";
-import HttpClient, { HttpClientRequestConfig } from "./HttpClient";
-import MultipartHttpClient from "./MultipartHttpClient";
-import { assertString } from "./parameterAssertUtils";
-import Credentials from "./Credentials";
-import Response from "./Response";
-
-let btoa: (str: string) => string;
-if (typeof window === "object") {
-    btoa = window.btoa || nodeBtoa;
-} else if (typeof global === "object") {
-    btoa = global.btoa || nodeBtoa;
-} else {
-    btoa = nodeBtoa;
-}
-
-/**
- * Create an object, which should be merged into the request header
- * object, which deals with the header's authorisation
- */
-function _getAuthHeader(credentials: Credentials | null) {
-    if (credentials && credentials.credentials) {
-        const btoaStr = `${credentials.credentials.uuid}:${credentials.hmac}`;
-        return { Authorization: `Basic ${btoa(btoaStr)}` };
-    }
-    return {};
-}
-
-interface AuthenticatedHttpClientOptions {
-    httpClient: HttpClient;
-    fetchDeviceCredentials: () => Promise<Credentials | null>;
-}
-
-const noCredentials: AuthenticatedHttpClientOptions["fetchDeviceCredentials"] = () => Promise.resolve(null);
-
-class AuthenticatedHttpClient {
-    private _httpClient: AuthenticatedHttpClientOptions["httpClient"];
-    private _fetchDeviceCredentials: AuthenticatedHttpClientOptions["fetchDeviceCredentials"];
-
-    constructor({ httpClient, fetchDeviceCredentials }: AuthenticatedHttpClientOptions) {
-        this._httpClient = httpClient;
-        this._fetchDeviceCredentials = fetchDeviceCredentials;
-    }
-
-    request(url: string, options: HttpClientRequestConfig): Promise<Response> {
-        return this._fetchDeviceCredentials().then((credentials) => {
-            const headers = Object.assign({}, options.headers, _getAuthHeader(credentials), {
-                "X-Appearin-Device-Platform": "web",
-            });
-
-            const httpClientOptions = Object.assign({}, options, { headers });
-
-            return this._httpClient.request(url, httpClientOptions);
-        });
-    }
-}
-
-interface ApiClientOptions {
-    baseUrl?: string;
-    fetchDeviceCredentials?: AuthenticatedHttpClientOptions["fetchDeviceCredentials"];
-}
-/**
- * Class used for all Whereby API calls.
- */
-export default class ApiClient {
-    authenticatedHttpClient: AuthenticatedHttpClient;
-    authenticatedFormDataHttpClient: MultipartHttpClient;
-
-    /**
-     * Create an ApiClient instance.
-     */
-    constructor({
-        baseUrl = "https://api.appearin.net",
-        fetchDeviceCredentials = noCredentials,
-    }: ApiClientOptions = {}) {
-        assertString(baseUrl, "baseUrl");
-        assert.ok(typeof fetchDeviceCredentials === "function", "fetchDeviceCredentials<Function> is required");
-
-        this.authenticatedHttpClient = new AuthenticatedHttpClient({
-            httpClient: new HttpClient({
-                baseUrl,
-            }),
-            fetchDeviceCredentials,
-        });
-
-        this.authenticatedFormDataHttpClient = new MultipartHttpClient({ httpClient: this.authenticatedHttpClient });
-    }
-
-    /**
-     * Wrapper for the fetch API
-     */
-    request(url: string, options: HttpClientRequestConfig): Promise<Response> {
-        assertString(url, "url");
-        assert.equal(url[0], "/", 'url<String> only accepts relative URLs beginning with "/".');
-        assert.ok(options, "options are required");
-
-        return this.authenticatedHttpClient.request(url, options);
-    }
-
-    /**
-     * Performs a multipart request where data is multipart/form-data encoded.
-     */
-    requestMultipart(url: string, options: HttpClientRequestConfig): Promise<Response> {
-        assertString(url, "url");
-        assert.equal(url[0], "/", 'url<String> only accepts relative URLs beginning with "/".');
-        assert.ok(options, "options are required");
-
-        return this.authenticatedFormDataHttpClient.request(url, options);
-    }
-}

package/src/lib/api/Credentials.ts

@@ -1,45 +0,0 @@
-import { extractJson, extractNullOrString, extractString } from "./extractUtils";
-import { Json } from "./Response";
-
-interface CredentialsOptions {
-    uuid: string;
-    hmac: string;
-    userId?: string;
-}
-
-export default class Credentials {
-    credentials: {
-        uuid: CredentialsOptions["uuid"];
-    };
-
-    hmac: CredentialsOptions["hmac"];
-    userId: CredentialsOptions["userId"];
-
-    constructor(
-        uuid: CredentialsOptions["uuid"],
-        hmac: CredentialsOptions["hmac"],
-        userId: CredentialsOptions["userId"] = undefined
-    ) {
-        this.credentials = {
-            uuid,
-        };
-        this.hmac = hmac;
-        this.userId = userId;
-    }
-
-    toJson(): Json {
-        return {
-            credentials: this.credentials,
-            hmac: this.hmac,
-            ...(this.userId && { userId: this.userId }),
-        };
-    }
-
-    static fromJson(json: Json): Credentials {
-        return new Credentials(
-            extractString(extractJson(json, "credentials"), "uuid"),
-            extractString(json, "hmac"),
-            extractNullOrString(json, "userId") || undefined
-        );
-    }
-}

package/src/lib/api/HttpClient.ts

@@ -1,95 +0,0 @@
-import assert from "assert";
-import axios, { AxiosError, AxiosRequestConfig, AxiosResponse } from "axios";
-import Response, { ErrorResponseObject } from "./Response";
-import { assertString } from "./parameterAssertUtils";
-
-export type HttpClientRequestConfig =
-    | AxiosRequestConfig
-    | { [key: string]: any };
-
-export interface IHttpClient {
-    request(url: string, options: HttpClientRequestConfig): Promise<Response>;
-}
-
-function _getAbsoluteUrl({ baseUrl, url }: { baseUrl?: string; url: string }): string {
-    assert.ok(typeof url === "string", "url<String> is required");
-    return baseUrl ? baseUrl + url : url;
-}
-
-/**
- * Class used for making http calls. This is just a pure
- * wrapper around the http lib that we decide to use,
- * so that we can switch implementations.
- */
-export default class HttpClient implements IHttpClient {
-    _baseUrl: string;
-    /**
-     * Creates an HttpClient instance.
-     *
-     * @param {string} [baseUrl] - The base URL where all requests are made.
-     */
-    constructor({ baseUrl }: { baseUrl: string }) {
-        assertString(baseUrl, "baseUrl");
-
-        this._baseUrl = baseUrl;
-    }
-
-    private _requestAxios(url: string, options: HttpClientRequestConfig): Promise<AxiosResponse> {
-        const axiosOptions = Object.assign({}, options, {
-            url,
-            baseURL: this._baseUrl,
-        });
-
-        return axios.request(axiosOptions);
-    }
-
-    /**
-     * Wrapper for the axios API
-     *
-     * @param {string} url - Required. URL (appended to base URL) where API call will be made
-     * @param {object} options - Required. Contains the data needed for the fetch API
-     * @return {Promise<Response>} - A promise which will return a Response object (https://developer.mozilla.org/en-US/docs/Web/API/Response)
-     */
-    request(url: string, options: HttpClientRequestConfig): Promise<Response> {
-        assertString(url, "url");
-        assert.equal(url[0], "/", 'url<String> only accepts relative URLs beginning with "/".');
-        assert.ok(options, "options are required");
-
-        return this._requestAxios(url, options)
-            .then((response) => {
-                const { data, headers, status, statusText, config } = response;
-                const requestUrl =
-                    config && config.url ? _getAbsoluteUrl({ baseUrl: config.baseURL, url: config.url }) : null;
-
-                return new Response({
-                    data,
-                    headers,
-                    status,
-                    statusText,
-                    url: requestUrl,
-                });
-            })
-            .catch((error: AxiosError) => {
-                const responseObject = error.response;
-
-                if (!responseObject) {
-                    // Either server error or something else.
-                    throw new Error("Could not make the request.");
-                }
-
-                const { data, headers, status, statusText, config } = responseObject as ErrorResponseObject;
-                const requestUrl =
-                    config && config.url ? _getAbsoluteUrl({ baseUrl: config.baseURL, url: config.url }) : null;
-
-                return Promise.reject(
-                    new Response({
-                        data,
-                        headers,
-                        status,
-                        statusText,
-                        url: requestUrl,
-                    })
-                );
-            });
-    }
-}

package/src/lib/api/MultipartHttpClient.ts

@@ -1,53 +0,0 @@
-import assert from "assert";
-import { HttpClientRequestConfig, IHttpClient } from "./HttpClient";
-import Response from "./Response";
-
-/**
- * ApiClient for doing multipart/form-data requests.
- */
-export default class MultipartHttpClient implements IHttpClient {
-    _httpClient: IHttpClient;
-
-    constructor({ httpClient }: { httpClient: IHttpClient }) {
-        assert.ok(httpClient, "httpClient is required");
-
-        this._httpClient = httpClient;
-    }
-
-    /**
-     * Convert the provided object to a FormData object containing the same keys and values.
-     * @param {object} data - the data to convert.
-     * @returns {FormData}
-     */
-    static dataToFormData(data: Record<string, string>): FormData {
-        assert.ok(data, "data is required");
-
-        const fd = new FormData();
-        Object.keys(data).forEach((key) => {
-            const value = data[key];
-            fd.append(key, value);
-        });
-        return fd;
-    }
-
-    /**
-     * Request a resource using multipart/form-data encoding.
-     *
-     * @param {string} url - the url to request
-     * @param {object} options - Required. Contains the data needed for the fetch API
-     * @return {Promise<Response>} - A promise which will return a Response object (https://developer.mozilla.org/en-US/docs/Web/API/Response)
-     */
-    request(url: string, options: HttpClientRequestConfig = {}): Promise<Response> {
-        const headers = Object.assign(options.headers || {}, {
-            "Content-Type": undefined,
-        });
-
-        return this._httpClient.request(
-            url,
-            Object.assign(options, {
-                headers,
-                transformRequest: MultipartHttpClient.dataToFormData,
-            })
-        );
-    }
-}

package/src/lib/api/OrganizationApiClient.ts

@@ -1,64 +0,0 @@
-import ApiClient from "./ApiClient";
-import assert from "assert";
-import { assertInstanceOf, assertString } from "./parameterAssertUtils";
-import { HttpClientRequestConfig } from "./HttpClient";
-import Response from "./Response";
-import Organization from "./models/Organization";
-
-const noOrganization = () => Promise.resolve(undefined);
-
-export type FetchOrganizationFunction = () => Promise<Organization | undefined>;
-
-/**
- * Class used for all Whereby organization API calls.
- */
-export default class OrganizationApiClient {
-    private _apiClient: ApiClient;
-    private _fetchOrganization: FetchOrganizationFunction;
-    /**
-     * Create an OrganizationApiClient instance.
-     *
-     * @param {ApiClient} [apiClient] - The apiClient to use.
-     * @param {Function} [fetchOrganization] - function that returns a promise with the organization.
-     */
-    constructor({
-        apiClient,
-        fetchOrganization = noOrganization,
-    }: {
-        apiClient: ApiClient;
-        fetchOrganization?: FetchOrganizationFunction;
-    }) {
-        this._apiClient = assertInstanceOf(apiClient, ApiClient);
-        assert.ok(typeof fetchOrganization === "function", "fetchOrganization<Function> is required");
-
-        this._fetchOrganization = fetchOrganization;
-        this._apiClient = apiClient;
-    }
-
-    _callRequestMethod(
-        method: "request" | "requestMultipart",
-        url: string,
-        options: HttpClientRequestConfig
-    ): Promise<Response> {
-        assertString(url, "url");
-        assert.equal(url[0], "/", 'url<String> only accepts relative URLs beginning with "/".');
-        assert.ok(options, "options are required");
-        return this._fetchOrganization().then((organization) => {
-            if (!organization) {
-                return this._apiClient[method](url, options);
-            }
-
-            const { organizationId } = organization;
-
-            return this._apiClient[method](`/organizations/${encodeURIComponent(organizationId)}${url}`, options);
-        });
-    }
-
-    request(url: string, options: HttpClientRequestConfig): Promise<Response> {
-        return this._callRequestMethod("request", url, options);
-    }
-
-    requestMultipart(url: string, options: HttpClientRequestConfig): Promise<Response> {
-        return this._callRequestMethod("requestMultipart", url, options);
-    }
-}

package/src/lib/api/Response.ts

@@ -1,34 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export type Json = string | number | boolean | null | Array<Json> | { [key: string]: Json };
-
-export type ErrorResponseObject = {
-    data?: Json;
-    headers?: Record<string, any>;
-    status?: number;
-    statusText?: string;
-    config?: { url?: string; baseURL?: string } | null;
-};
-
-interface ResponseOptions {
-    data?: Json;
-    headers?: Record<string, any>;
-    status?: number;
-    statusText?: string;
-    url?: string | null;
-}
-
-export default class Response {
-    data: Json;
-    headers: Record<string, unknown>;
-    status: number;
-    statusText: string;
-    url: string | null;
-
-    constructor(initialValues: ResponseOptions = {}) {
-        this.data = initialValues.data === undefined ? {} : initialValues.data;
-        this.headers = initialValues.headers || {};
-        this.status = initialValues.status || 200;
-        this.statusText = initialValues.statusText || "OK";
-        this.url = initialValues.url || null;
-    }
-}

package/src/lib/api/credentialsService/index.ts

@@ -1,159 +0,0 @@
-import EventEmitter from "events";
-
-import DeviceService from "../deviceService/index";
-import AbstractStore from "../modules/AbstractStore";
-import ChromeStorageStore from "../modules/ChromeStorageStore";
-import LocalStorageStore from "../modules/LocalStorageStore";
-import { assertInstanceOf } from "../parameterAssertUtils";
-import ApiClient from "../ApiClient";
-import localStorage from "../localStorageWrapper";
-import { Credentials } from "..";
-
-/**
- * Events triggered by this service
- */
-export const events = {
-    CREDENTIALS_SAVED: "credentials_saved",
-};
-
-export default class CredentialsService extends EventEmitter {
-    _deviceService: DeviceService;
-    _credentialsStore: AbstractStore;
-    credentialsPromise?: Promise<Credentials | null>;
-
-    /**
-     * Service to manage Whereby's Rest API credentials.
-     *
-     * @param {ObjectStore} credentialsStore - Store to manage the credentials.
-     */
-    constructor({
-        deviceService,
-        credentialsStore,
-    }: {
-        deviceService: DeviceService;
-        credentialsStore: AbstractStore;
-    }) {
-        super();
-        this._deviceService = assertInstanceOf(deviceService, DeviceService);
-        this._credentialsStore = credentialsStore;
-    }
-
-    static create({
-        baseUrl,
-        storeName = "CredentialsStorage",
-        storeType = "localStorage",
-    }: {
-        baseUrl: string;
-        storeName?: string;
-        storeType?: "localStorage" | "chromeStorage";
-    }): CredentialsService {
-        const deviceService = new DeviceService({
-            apiClient: new ApiClient({ baseUrl }),
-        });
-
-        let credentialsStore = null;
-
-        if (storeType === "localStorage") {
-            credentialsStore = new LocalStorageStore(storeName, localStorage);
-        } else if (storeType === "chromeStorage") {
-            credentialsStore = new ChromeStorageStore(storeName, window["chrome"].storage.local);
-        } else {
-            throw new Error(`Unknown store type: ${storeType}`);
-        }
-
-        return new CredentialsService({
-            deviceService,
-            credentialsStore,
-        });
-    }
-    /**
-     * Contacts the REST API to get new credentials. DO NOT USE directly, call getCredentials() instead.
-     *
-     * @see getCredentials
-     * @returns {Promise.<Credentials>} - Promise that resolves with the credentials.
-     */
-    _fetchNewCredentialsFromApi(): Promise<Credentials | null> {
-        const credentialsStore = this._credentialsStore;
-        return new Promise((resolve) => {
-            const fetchCredentials = () => {
-                this._deviceService
-                    .getCredentials()
-                    .then((credentials) => {
-                        return credentialsStore
-                            .save(credentials ? credentials.toJson() : null)
-                            .then(() => resolve(credentials));
-                    })
-                    .catch(() => {
-                        setTimeout(fetchCredentials, 2000);
-                    });
-            };
-            fetchCredentials();
-        });
-    }
-
-    /**
-     * Returns the current credentials without triggering an API request to get new ones.
-     * If no credentials are currently available it will return null.
-     *
-     * @returns {?Credentials} - The credentials currently in use, null otherwise.
-     */
-    getCurrentCredentials(): Promise<Credentials | null> {
-        return this._credentialsStore.loadOrDefault(null).then((json) => (json ? Credentials.fromJson(json) : null));
-    }
-
-    /**
-     * Returns a promise that will contain the credentials for this client.
-     * If no credentials are available in local storage, new ones will be fetched from the server.
-     *
-     * @returns {Promise.<Credentials>} - Promise that resolves with the credentials.
-     */
-    getCredentials(): Promise<Credentials | null> {
-        if (!this.credentialsPromise) {
-            this.credentialsPromise = this.getCurrentCredentials().then((storedCredentials) => {
-                if (storedCredentials) {
-                    return storedCredentials;
-                }
-
-                return this._fetchNewCredentialsFromApi();
-            });
-        }
-
-        return this.credentialsPromise;
-    }
-
-    /**
-     * Saves new credentials which replace the existing ones and abort any pending request to get new ones.
-     *
-     * @param {Credentials} credentials - New credentials to store.
-     */
-    saveCredentials(credentials: Credentials): Promise<Credentials> {
-        this.credentialsPromise = undefined;
-        return this._credentialsStore.save(credentials.toJson()).then(() => {
-            this.emit(events.CREDENTIALS_SAVED, credentials);
-            return credentials;
-        });
-    }
-
-    /**
-     * It will set the userId for the current credentials.
-     *
-     * @param userId - The user id to set.
-     */
-    setUserId(userId: string | null): Promise<void> {
-        // Used to ensure that the userId is changed if localStorage has been modified by another tab
-        return this.getCurrentCredentials()
-            .then((storedCredentials) => {
-                if (!storedCredentials) {
-                    console.error("Illegal state: no credentials to set user id for."); // eslint-disable-line no-console
-                }
-
-                const userIdChangedFromLocalStorage = storedCredentials === null || storedCredentials.userId !== userId;
-                if (!userIdChangedFromLocalStorage) {
-                    return undefined;
-                }
-
-                return this._credentialsStore.save(Object.assign({}, storedCredentials?.toJson(), { userId }));
-            })
-            .then(() => undefined);
-    }
-}