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

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

@@ -1,181 +0,0 @@
-// @ts-nocheck
-import ApiClient from "../../ApiClient";
-import Credentials from "../../Credentials";
-import CredentialsService, { events } from "../index";
-import LocalStorageStore from "../../modules/LocalStorageStore";
-import DeviceService from "../../deviceService/index";
-
-jest.mock("../../modules/LocalStorageStore")
-jest.mock("../../deviceService")
-
-describe("CredentialsService", () => {
-    let apiClient;
-    let deviceService;
-    let credentialsStore;
-    let credentialsService;
-    let storedCredentials;
-
-    beforeEach(() => {
-        apiClient = new ApiClient() as jest.Mocked<ApiClient>;
-        credentialsStore = new LocalStorageStore;
-        deviceService = new DeviceService({ apiClient });
-        credentialsService = new CredentialsService({
-            deviceService,
-            credentialsStore,
-        });
-        storedCredentials = new Credentials("test-stored-uuid", "test-stored-hmac");
-    });
-
-    describe("getCurrentCredentials", () => {
-        it("should load credentials from the store", async () => {
-            credentialsStore.loadOrDefault.mockResolvedValue(storedCredentials.toJson());
-
-            const result = await credentialsService.getCurrentCredentials();
-
-            expect(result).toEqual(storedCredentials);
-        });
-
-        it("should load credentials from the store", () => {
-            credentialsStore.loadOrDefault.mockResolvedValue(storedCredentials.toJson());
-
-            credentialsService.getCurrentCredentials();
-
-            return expect(credentialsStore.loadOrDefault).toBeCalled();
-        });
-    });
-
-    describe("getCredentials", () => {
-        describe("when no credentials are available in localStorage", () => {
-            let apiCredentials;
-            beforeEach(() => {
-                apiCredentials = new Credentials("test-fetched-uuid", "test-fetched-hmac");
-                credentialsStore.loadOrDefault.mockResolvedValue(null);
-                credentialsStore.save.mockResolvedValue();
-                deviceService.getCredentials.mockResolvedValue(apiCredentials);
-            });
-
-            it("should save the fetched credentials to credentialsStore", () => {
-                const promise = credentialsService.getCredentials();
-
-                return promise.then(() => {
-                    expect(credentialsStore.save).toBeCalledWith(apiCredentials.toJson());
-                });
-            });
-
-            it("should fetch new credentials from the API", async () => {
-                await credentialsService.getCredentials();
-
-                expect(deviceService.getCredentials).toBeCalledTimes(1);
-            });
-
-            it("should resolve with the credentials from the api", async () => {
-                const result = await credentialsService.getCredentials();
-
-                return expect(result).toEqual(apiCredentials);
-            });
-        });
-
-        describe("when credentials are available in localStorage", () => {
-            beforeEach(() => {
-                credentialsStore.loadOrDefault.mockResolvedValue(storedCredentials);
-                deviceService.getCredentials.mockResolvedValue(null);
-            });
-
-            it("should not fetch new credentials from the api", () => {
-                const promise = credentialsService.getCredentials();
-
-                return promise.then(() => {
-                    expect(deviceService.getCredentials).not.toBeCalled();
-                });
-            });
-
-            it("should return credentials from localstorage", async () => {
-                const result = await credentialsService.getCredentials();
-
-                expect(result).toEqual(storedCredentials);
-            });
-        });
-    });
-
-    describe("saveCredentials", () => {
-        it("should save the credentials to localStorage", () => {
-            credentialsStore.save.mockResolvedValue();
-
-            const promise = credentialsService.saveCredentials(storedCredentials);
-
-            return promise.then(() => {
-                expect(credentialsStore.save).toBeCalledWith(storedCredentials.toJson());
-            });
-        });
-
-        it("should fire the CREDENTIALS_SAVED event", () => {
-            credentialsStore.save.mockResolvedValue();
-            const callback = jest.fn();
-            credentialsService.on(events.CREDENTIALS_SAVED, callback);
-
-            const promise = credentialsService.saveCredentials(storedCredentials);
-
-            return promise.then(() => {
-                expect(callback).toBeCalled();
-            });
-        });
-    });
-
-    describe("setUserId", () => {
-        const mockUserId = "1234ef-987654-a1b2cd3e";
-
-        describe("when no credentials are stored", () => {
-            beforeEach(() => {
-                jest.spyOn(console, "error").mockClear().mockImplementation();
-                credentialsStore.loadOrDefault.mockResolvedValue(null);
-            });
-
-            afterEach(() => {
-                console.error.mockRestore(); // eslint-disable-line no-console
-            });
-
-            it("should call log an error", () => {
-                const promise = credentialsService.setUserId(mockUserId);
-
-                return promise.then(() => {
-                    expect(console.error).toBeCalled(); // eslint-disable-line no-console
-                });
-            });
-
-            it("should return undefined", async () => {
-                const result = await credentialsService.setUserId(mockUserId);
-
-                expect(result).toBeUndefined();
-            });
-        });
-
-        describe("when have been credentials have been stored", () => {
-            [null, "some-new-userId"].forEach((newUserId) => {
-                let credentialsWithUserId;
-                beforeEach(() => {
-                    credentialsWithUserId = new Credentials("some-uuid", "some-hmac", "some-userId");
-                    credentialsStore.loadOrDefault.mockResolvedValue(credentialsWithUserId);
-                });
-
-                it("should return undefined", async () => {
-                    const result = await credentialsService.setUserId(newUserId);
-
-                    expect(result).toBeUndefined();
-                });
-
-                it(
-                    "should set the userId property in the credentials and store them when it has changed",
-                    () => {
-                        const expectedCredentials = Object.assign({}, credentialsWithUserId, { userId: newUserId });
-
-                        const promise = credentialsService.setUserId(newUserId);
-
-                        return promise.then(() => {
-                            expect(credentialsStore.save).toBeCalledWith(expectedCredentials);
-                        });
-                    }
-                );
-            });
-        });
-    });
-});

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

@@ -1,42 +0,0 @@
-import ApiClient from "../ApiClient";
-import { assertInstanceOf } from "../parameterAssertUtils";
-import Credentials from "../Credentials";
-
-/**
- * Related to device calls needed to obtain credentials
- */
-export default class DeviceService {
-    _apiClient: ApiClient;
-
-    constructor({ apiClient }: { apiClient: ApiClient }) {
-        this._apiClient = assertInstanceOf(apiClient, ApiClient);
-    }
-
-    /**
-     * Get's the device credentials needed for most of the other API services
-     *
-     * @return {Promise} A promise which is fulfilled or failed based on the
-     * response.
-     */
-    getCredentials(): Promise<Credentials | null> {
-        return this._apiClient
-            .request("/devices", {
-                method: "post",
-            })
-            .then(({ data }) => {
-                return Credentials.fromJson(data);
-            })
-            .catch((error) => {
-                if (error.response) {
-                    // The request was made, but the server responded with a status code
-                    // that falls out of the range of 2xx
-                    if (error.response.status === 404) {
-                        return null;
-                    }
-                }
-
-                // Something happened in setting up the request that triggered an Error
-                throw error;
-            });
-    }
-}

package/src/lib/api/deviceService/tests/index.spec.ts

@@ -1,74 +0,0 @@
-import DeviceService from "../index";
-import ApiClient from "../../ApiClient";
-import Credentials from "../../Credentials";
-import { itShouldThrowIfInvalid } from "../../test/helpers";
-import Response from "../../Response";
-
-jest.mock("../../ApiClient");
-
-const credentials = {
-    credentials: {
-        uuid: "12345",
-    },
-    hmac: "67890",
-};
-
-describe("deviceService", () => {
-    let apiClient: jest.Mocked<ApiClient>;
-    let deviceService: DeviceService;
-
-    beforeEach(() => {
-        apiClient = new ApiClient() as jest.Mocked<ApiClient>;
-        deviceService = new DeviceService({ apiClient });
-    });
-
-    describe("constructor", () => {
-        itShouldThrowIfInvalid(
-            "apiClient",
-            () =>
-                new DeviceService({
-                    //@ts-expect-error
-                    apiClient: undefined,
-                })
-        );
-    });
-
-    describe("getCredentials", () => {
-        const url = "/devices";
-        const method = "post";
-
-        beforeEach(() => {
-            apiClient.request.mockResolvedValue(new Response({ data: credentials }));
-        });
-
-        it("should call request with correct params", async () => {
-            await deviceService.getCredentials();
-
-            expect(apiClient.request).toBeCalledWith(url, {
-                method,
-            });
-        });
-
-        it("should be fulfilled with the credentials success", async () => {
-            const result = await deviceService.getCredentials();
-
-            expect(result).toEqual(new Credentials(credentials.credentials.uuid, credentials.hmac));
-        });
-
-        it("should fail if the request failed", async () => {
-            const error = new Error("some error");
-            apiClient.request.mockRejectedValue(error);
-
-            await expect(deviceService.getCredentials()).rejects.toThrow(error);
-        });
-
-        it("should return null if the server is down", async () => {
-            const response = { response: { status: 404 } };
-            apiClient.request.mockRejectedValue(response);
-
-            const result = await deviceService.getCredentials();
-
-            expect(result).toEqual(null);
-        });
-    });
-});

package/src/lib/api/extractUtils.ts

@@ -1,160 +0,0 @@
-import { assertArray, assertBoolean, assertNumber, assertRecord, assertString } from "./parameterAssertUtils";
-import { Json } from "./Response";
-
-export type Extractor<T> = (data: Json, propertyName: string) => T;
-export type Transformer<T> = (data: Json) => T;
-
-/**
- * Utility function to transform the given transformer function into a
- * function that handles `undefined` and `null` values.
- *
- * @param transformer - Function to transform
- * @returns the transformed function.
- */
-export function nullOrTransform<T>(transform: Transformer<T>): Transformer<T | null> {
-    return (data: Json): T | null => {
-        return data === null || data === undefined ? null : transform(data);
-    };
-}
-
-/**
- * Utility function to transform the given extract function to allow
- * `undefined` and `null` values.
- * @param extract - Function to transform
- * @returns the transformed function.
- */
-export function nullOrExtract<T>(extract: Extractor<T>): Extractor<T | null> {
-    return (data: Json, propertyName: string): T | null => {
-        const record = assertRecord(data, "data");
-
-        const value = record[propertyName];
-        return value === null || value === undefined ? null : extract(data, propertyName);
-    };
-}
-
-/**
- * Extract a boolean from the given Json object.
- * If the value is not a boolean, an error is thrown.
- *
- * @param data - the object to extract the value from
- * @param propertyName - the name of the parameter to extract
- * @returns the extracted value
- */
-export function extractBoolean(data: Json, propertyName: string): boolean {
-    const record = assertRecord(data, "data");
-    return assertBoolean(record[propertyName], propertyName);
-}
-
-/**
- * Extract a string from the given Json object.
- * If the value is not a string, an error is thrown.
- *
- * @param data - the object to extract the value from
- * @param propertyName - the name of the parameter to extract
- * @returns the extracted value
- */
-export function extractString(data: Json, propertyName: string): string {
-    const record = assertRecord(data, "data");
-    return assertString(record[propertyName], propertyName);
-}
-
-export const extractNullOrString = nullOrExtract(extractString);
-
-/**
- * Extract a number from the given Json object.
- * If the value is not a number, an error is thrown.
- *
- * @param data - the object to extract the value from
- * @param propertyName - the name of the parameter to extract
- * @returns the extracted value
- */
-export function extractNumber(data: Json, propertyName: string): number {
-    const record = assertRecord(data, "data");
-    return assertNumber(record[propertyName], propertyName);
-}
-
-export const extractNullOrNumber = nullOrExtract(extractNumber);
-
-/**
- * Extract a Date from the given Json object.
- * If the value is not a valid Date, an error is thrown.
- *
- * @param data - the object to extract the value from
- * @param propertyName - the name of the parameter to extract
- * @returns the extracted value
- */
-export function extractDate(data: Json, propertyName: string): Date {
-    const dateString = extractString(data, propertyName);
-    const d = new Date(dateString);
-    if (isNaN(d.getTime())) {
-        throw new Error(`Invalid date for ${dateString}`);
-    }
-
-    return d;
-}
-
-export const extractNullOrDate: (data: Json, propertyName: string) => Date | null = nullOrExtract(extractDate);
-
-/**
- * Extract an Array from the given Json object.
- * If the value is not a valid Array, an error is thrown.
- *
- * @param data - the object to extract the value from
- * @param propertyName - the name of the parameter to extract
- * @returns the extracted value
- **/
-export function extractArrayOfJson(data: Json, propertyName: string): Array<Json> {
-    const record = assertRecord(data, "data");
-    return assertArray(record[propertyName], propertyName) as Array<Json>;
-}
-
-/**
- * Extract an Array from the given Json object and run the provided
- * transformer on all of the provided values.
- * If the value is not a valid Array, an error is thrown.
- *
- * @param data - the object to extract the value from
- * @param propertyName - the name of the parameter to extract
- * @param transformer - A function to transform all the Json elements extracted from the parameter
- * @returns the extracted value
- **/
-export function extractArray<T>(data: Json, propertyName: string, transformer: Transformer<T>): Array<T> {
-    return extractArrayOfJson(data, propertyName).map((value) => transformer(value));
-}
-
-/**
- * Extract a Json object from the given Json object.
- * If the value is not a valid Json object, an error is thrown.
- *
- * Note, if the extracted value is undefined, null will be returned
- * since the extractor functions don't distinguish an undefined value
- * and a null value.
- *
- * @param data - the object to extract the value from
- * @param propertyName - the name of the parameter to extract
- * @returns the extracted value
- */
-export function extractJson(data: Json, propertyName: string): Json {
-    const record = assertRecord(data, "data") as Record<string, Json>;
-
-    const value = record[propertyName];
-    return value === undefined ? null : value;
-}
-
-/**
- * Extract a Json object from the given Json object and transform
- * that value using the given transformer function.
- * If the provided json object is not a valid Json object, an error is thrown.
- *
- * Note, if the extracted value is undefined, null will be returned
- * since the extractor functions don't distinguish an undefined value
- * and a null value.
- *
- * @param data - the object to extract the value from
- * @param propertyName - the name of the parameter to extract
- * @param transformer - A function to transform the extracted value
- * @returns the extracted and transformed value
- **/
-export function extractJsonWithTransform<T>(data: Json, propertyName: string, transformer: Transformer<T>): T {
-    return transformer(extractJson(data, propertyName));
-}

package/src/lib/api/index.ts

@@ -1,8 +0,0 @@
-export { default as ApiClient } from "./ApiClient"
-export { default as CredentialsService } from "./credentialsService"
-export { default as Credentials } from "./Credentials"
-export { default as OrganizationApiClient } from "./OrganizationApiClient"
-export { default as OrganizationService } from "./organizationService"
-export { default as OrganizationServiceCache } from "./organizationServiceCache"
-export { default as RoomService } from "./roomService"
-

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

@@ -1,15 +0,0 @@
-let localStorage;
-try {
-    localStorage = self.localStorage;
-} catch (e) {
-    localStorage = {
-        getItem: (): undefined => undefined,
-        key: (): undefined => undefined,
-        setItem: (): undefined => undefined,
-        removeItem: (): undefined => undefined,
-        hasOwnProperty: (): undefined => undefined,
-        length: 0,
-    };
-}
-
-export default localStorage as Storage;

package/src/lib/api/models/Account.ts

@@ -1,48 +0,0 @@
-import { assertBoolean } from "../parameterAssertUtils";
-import EmbeddedFreeTierStatus from "./account/EmbeddedFreeTierStatus";
-
-interface AccountProps {
-    basePlanId: string | null;
-    isDeactivated: boolean;
-    isOnTrial: boolean;
-    onTrialUntil: Date | null;
-    trialStatus: string | null;
-    embeddedFreeTierStatus: EmbeddedFreeTierStatus | null;
-}
-export default class Account {
-    basePlanId: string | null;
-    embeddedFreeTierStatus: EmbeddedFreeTierStatus | null;
-    isDeactivated: boolean;
-    isOnTrial: boolean;
-    onTrialUntil: Date | null;
-    trialStatus: string | null;
-
-    constructor({
-        basePlanId,
-        embeddedFreeTierStatus,
-        isDeactivated,
-        isOnTrial,
-        onTrialUntil,
-        trialStatus,
-    }: AccountProps) {
-        this.basePlanId = basePlanId;
-        this.isDeactivated = isDeactivated;
-        this.isOnTrial = isOnTrial;
-        this.onTrialUntil = onTrialUntil || null;
-        this.trialStatus = trialStatus || null;
-        this.embeddedFreeTierStatus = embeddedFreeTierStatus || null;
-    }
-
-    static fromJson(data: Record<string, unknown>): Account {
-        return new Account({
-            basePlanId: typeof data.basePlanId === "string" ? data.basePlanId : null,
-            isDeactivated: assertBoolean(data.isDeactivated, "isDeactivated"),
-            isOnTrial: assertBoolean(data.isOnTrial, "isOnTrial"),
-            onTrialUntil: typeof data.onTrialUntil === "string" ? new Date(data.onTrialUntil) : null,
-            trialStatus: typeof data.trialStatus === "string" ? data.trialStatus : null,
-            embeddedFreeTierStatus: data.embeddedFreeTierStatus
-                ? EmbeddedFreeTierStatus.fromJson(data.embeddedFreeTierStatus as Record<string, unknown>)
-                : null,
-        });
-    }
-}

package/src/lib/api/models/Meeting.ts

@@ -1,42 +0,0 @@
-import { extractDate, extractNullOrString, extractString } from "../extractUtils";
-import { assertString, assertInstanceOf } from "../parameterAssertUtils";
-import { Json } from "../Response";
-
-export default class Meeting {
-    meetingId: string;
-    roomName: string;
-    roomUrl: string;
-    startDate: Date;
-    endDate: Date;
-    hostRoomUrl: string | null;
-    viewerRoomUrl: string | null;
-
-    constructor({ meetingId, roomName, roomUrl, startDate, endDate, hostRoomUrl, viewerRoomUrl }: Meeting) {
-        assertString(meetingId, "meetingId");
-        assertString(roomName, "roomName");
-        assertString(roomUrl, "roomUrl");
-
-        assertInstanceOf(startDate, Date, "startDate");
-        assertInstanceOf(endDate, Date, "endDate");
-
-        this.meetingId = meetingId;
-        this.roomName = roomName;
-        this.roomUrl = roomUrl;
-        this.startDate = startDate;
-        this.endDate = endDate;
-        this.hostRoomUrl = hostRoomUrl;
-        this.viewerRoomUrl = viewerRoomUrl;
-    }
-
-    static fromJson(data: Json): Meeting {
-        return new Meeting({
-            meetingId: extractString(data, "meetingId"),
-            roomName: extractString(data, "roomName"),
-            roomUrl: extractString(data, "roomUrl"),
-            startDate: extractDate(data, "startDate"),
-            endDate: extractDate(data, "endDate"),
-            hostRoomUrl: extractNullOrString(data, "hostRoomUrl"),
-            viewerRoomUrl: extractNullOrString(data, "viewerRoomUrl"),
-        });
-    }
-}