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

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

@@ -1,28 +0,0 @@
-import { assertInstanceOf, assertString } from "../parameterAssertUtils";
-import OrganizationService from "../organizationService/index";
-import Organization from "../models/Organization";
-
-export default class OrganizationServiceCache {
-    private _organizationService: OrganizationService;
-    private _subdomain: string;
-    private _organizationPromise: Promise<Organization | null> | null;
-
-    constructor({ organizationService, subdomain }: { organizationService: OrganizationService; subdomain: string }) {
-        assertInstanceOf(organizationService, OrganizationService);
-        assertString(subdomain, "subdomain");
-        this._organizationService = organizationService;
-        this._subdomain = subdomain;
-        this._organizationPromise = null;
-    }
-
-    initOrganization(): Promise<void> {
-        return this.fetchOrganization().then(() => undefined);
-    }
-
-    fetchOrganization(): Promise<Organization | null> {
-        if (!this._organizationPromise) {
-            this._organizationPromise = this._organizationService.getOrganizationBySubdomain(this._subdomain);
-        }
-        return this._organizationPromise;
-    }
-}

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

@@ -1,101 +0,0 @@
-// @ts-nocheck
-import ApiClient from "../../ApiClient";
-import OrganizationServiceCache from "../index";
-import OrganizationService from "../../organizationService";
-import Organization from "../../models/Organization";
-import { itShouldThrowIfInvalid } from "../../test/helpers";
-
-jest.mock("../../organizationService");
-
-describe("OrganizationServiceCache", () => {
-    let apiClient: jest.Mocked<ApiClient>;
-    let organizationService: OrganizationService;
-    let organizationServiceCache: OrganizationServiceCache;
-    let subdomain: string | undefined;
-    let organization: Organization;
-
-    beforeEach(() => {
-        subdomain = "someOrganization";
-        const permissions = {};
-        const limits = {
-            maxNumberOfClaimedRooms: null,
-        };
-        apiClient = new ApiClient() as jest.Mocked<ApiClient>;
-
-        organization = new Organization({
-            organizationId: "1",
-            organizationName: "some-name",
-            subdomain: "someOrganization",
-            permissions,
-            limits,
-        });
-        organizationService = new OrganizationService({ apiClient });
-        organizationService.getOrganizationBySubdomain.mockResolvedValue(organization);
-        organizationServiceCache = new OrganizationServiceCache({
-            subdomain,
-            organizationService,
-        });
-    });
-
-    describe("constructor", () => {
-        itShouldThrowIfInvalid(
-            "subdomain",
-            () =>
-                new OrganizationServiceCache({
-                    subdomain: undefined,
-                    organizationService,
-                })
-        );
-
-        itShouldThrowIfInvalid(
-            "organizationService",
-            () =>
-                new OrganizationServiceCache({
-                    subdomain,
-                    organizationService: undefined,
-                })
-        );
-    });
-
-    describe("initOrganization", () => {
-        it("should do nothing", async () => {
-            await organizationServiceCache.initOrganization();
-
-            expect(organizationService.getOrganizationBySubdomain).toBeCalledWith(subdomain);
-        });
-
-        it("should resolve with undefined", async () => {
-            const result = await organizationServiceCache.initOrganization();
-
-            expect(result).toBeUndefined();
-        });
-    });
-
-    describe("fetchOrganization", () => {
-        describe("when cache is uninitialized", () => {
-            it("should fetch the organization state", async () => {
-                await organizationServiceCache.fetchOrganization();
-
-                expect(organizationService.getOrganizationBySubdomain).toBeCalledWith(subdomain);
-            });
-        });
-
-        describe("when organization has been fetched once", () => {
-            beforeEach(() => {
-                return organizationServiceCache.fetchOrganization();
-            });
-
-            it("should do nothing", async () => {
-                organizationServiceCache.fetchOrganization();
-
-                expect(organizationService.getOrganizationBySubdomain).toBeCalledWith(subdomain);
-            });
-        });
-
-        it("should return the organization returned from the organizationService", async () => {
-            const result = await organizationServiceCache.fetchOrganization();
-
-            expect(result).toEqual(organization);
-        });
-    });
-});

package/src/lib/api/parameterAssertUtils.ts

@@ -1,166 +0,0 @@
-import assert from "assert";
-
-/**
- * Asserts that value is truthy.
- *
- * @param value - The value to check.
- * @param {string} parameterName - The name of the parameter.
- */
-export function assertTruthy(value: unknown, parameterName: string): unknown {
-    assert.ok(value, `${parameterName} is required`);
-    return value;
-}
-
-/**
- * Asserts that value is a number.
- *
- * @param value - The value to check.
- * @param {string} parameterName - The name of the parameter.
- */
-export function assertBoolean(value: unknown, parameterName: string): boolean {
-    assert.ok(typeof value === "boolean", `${parameterName}<boolean> is required`);
-    return value;
-}
-
-/**
- * Asserts that value is a number.
- *
- * @param value - The value to check.
- * @param {string} parameterName - The name of the parameter.
- */
-export function assertNumber(value: unknown, parameterName: string): number {
-    assert.ok(typeof value === "number", `${parameterName}<number> is required`);
-    return value;
-}
-
-/**
- * Asserts that value is a string.
- *
- * @param value - The value to check.
- * @param {string} parameterName - The name of the parameter.
- */
-export function assertString(value: unknown, parameterName: string): string {
-    assert.ok(typeof value === "string", `${parameterName}<string> is required`);
-    return value;
-}
-
-/**
- * Asserts that value is of the provided type.
- *
- * @param value - The value to check.
- * @param type - The type that value should be.
- * @param {string} [parameterName] - The name of the parameter.
- */
-export function assertInstanceOf<T>(value: unknown, type: new (any: any) => T, parameterName?: string): T {
-    const resolvedParameterName = parameterName || type.name[0].toLowerCase() + type.name.substring(1);
-    assert.ok(value instanceof type, `${resolvedParameterName}<${type.name}> is required`);
-    return value;
-}
-
-/**
- * Asserts that the provided room name is a valid roomName.
- *
- * @param roomName - The roomName to check.
- * @param {string} [parameterName="roomName"] - The name of the parameter.
- */
-export function assertRoomName(roomName: unknown, parameterName = "roomName"): string {
-    assertString(roomName, parameterName);
-    assert.equal(typeof roomName === "string" && roomName[0], "/", `${parameterName} must begin with a '/'`);
-    return roomName as string;
-}
-
-/**
- * Asserts that the provided array is a valid array.
- *
- * @param array - The array to check.
- * @param {string} [parameterName] - The name of the parameter.
- */
-export function assertArray(array: unknown, parameterName: string): Array<unknown> {
-    assert.ok(Array.isArray(array), `${parameterName}<array> is required`);
-    return array as Array<unknown>;
-}
-
-/**
- * Asserts that value is one of the values provided in an array
- *
- * @param value - The value to check.
- * @param allowedValues - An array of allowed values
- * @param {string} parameterName - The name of the parameter.
- */
-export function assertOneOf<T>(value: T, allowedValues: Array<unknown>, parameterName: string): T {
-    assertTruthy(value, "value");
-    assertArray(allowedValues, "allowedValues");
-
-    const isAllowed = allowedValues.includes(value);
-    if (!isAllowed) {
-        throw new Error(`${parameterName}<string> must be one of the following: ${allowedValues.join(", ")}`);
-    }
-
-    return value;
-}
-
-/**
- * Asserts that the provided reference is of the provided primitive type.
- *
- * @param {*} ref - The reference (variable or constant) to test.
- * @param {string} type - The expected primitive type.
- * @param {string} name - The name of the reference, will be used in the error message.
- * @param {string} [message] - A custom message to use when the assertion fails.
- */
-export function assertType(ref: unknown, type: string, name: string, message?: string): void {
-    assert.ok(typeof name === "string", "name must be of type string");
-    const errorMessage = message || `${name} must be of type ${type}`;
-    assert.ok(ref !== null && typeof ref === type, errorMessage);
-}
-
-/**
- * Asserts that the provided reference is a record.
- *
- * @param {*} ref - The reference (variable or constant) to test.
- * @param {string} name - The name of the reference, will be used in the error message.
- */
-export function assertRecord(ref: unknown, name: string): Record<string, unknown> {
-    if (ref === null || ref === undefined || typeof ref !== "object" || Array.isArray(ref)) {
-        throw new Error(`${name} must be a record. ${JSON.stringify(ref)}`);
-    }
-
-    return ref as Record<string, unknown>;
-}
-
-/**
- * Asserts that the provided reference is either null or of the provided primitive type.
- *
- * @param {*} ref - The reference (variable or constant) to test.
- * @param {string} type - The expected primitive type.
- * @param {string} name - The name of the reference, will be used in the error message.
- * @param {string} [message] - A custom message to use when the assertion fails.
- */
-export function assertNullOrType(ref: unknown, type: string, name: string, message?: string): void {
-    assertString(name, "name");
-    const errorMessage = message || `${name} must be null or of type ${type}`;
-    assert.ok(ref === null || typeof ref === type, errorMessage);
-}
-
-/**
- * Asserts that the provided reference is either null or a boolean.
- *
- * @param {*} ref - The reference (variable or constant) to test.
- * @param {string} name - The name of the reference, will be used in the error message.
- * @param {string} [message] - A custom message to use when the assertion fails.
- */
-export function assertNullOrBoolean(ref: unknown, name: string, message?: string): void {
-    assertString(name, "name");
-    assertNullOrType(ref, "boolean", name, message);
-}
-
-/**
- * Asserts that the provided reference is either null or a string.
- *
- * @param {*} ref - The reference (variable or constant) to test.
- * @param {string} name - The name of the reference, will be used in the error message.
- * @param {string} [message] - A custom message to use when the assertion fails.
- */
-export function assertNullOrString(ref: unknown, name: string, message?: string): void {
-    assertString(name, "name");
-    assertNullOrType(ref, "string", name, message);
-}

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

@@ -1,310 +0,0 @@
-// @ts-nocheck
-import Room from "../models/Room";
-import {
-    assertInstanceOf,
-    assertRoomName,
-    assertString,
-    assertArray,
-    assertOneOf,
-    assertNumber,
-} from "../parameterAssertUtils";
-import OrganizationApiClient from "../OrganizationApiClient";
-import Meeting from "../models/Meeting";
-
-function createRoomUrl(roomName, path = "") {
-    const encodedDisplayName = encodeURIComponent(roomName.substring(1));
-    return `/room/${encodedDisplayName}${path}`;
-}
-
-/**
- * Service for talking to the Room related APIs
- */
-export default class RoomService {
-    /**
-     * @param {object} organizationApiClient (required)
-     */
-    constructor({ organizationApiClient }) {
-        this._organizationApiClient = assertInstanceOf(organizationApiClient, OrganizationApiClient);
-    }
-
-    /**
-     * Gets the list of visited rooms
-     *
-     * @param {Object} args
-     * @param {Array<string>} [types=["team"]] - The type of rooms that should be fetched.
-     * @param {Array<string>} [fields=["meeting"]] - The fields of room that should be fetched.
-     * @returns {Promise<array>} - It will resolve with an array.
-     */
-    getRooms({ types, fields = [] } = {}) {
-        assertArray(types, "types");
-        assertArray(fields, "fields");
-        return this._organizationApiClient
-            .request("/room", {
-                method: "GET",
-                params: { types: types.join(","), fields: fields.join(","), includeOnlyLegacyRoomType: "false" },
-            })
-            .then(({ data }) => data.rooms.map((room) => new Room(room)));
-    }
-
-    /**
-     * Gets the specified room.
-     *
-     * Currently information is implicitly alluded to via the servers
-     * `/room/roomName` response. This method patches the data
-     * tempoarily, until the day it comes back from the server.
-     *
-     * @returns {Promise<Room>} - It will resolve with the Room.
-     */
-    getRoom({ roomName, fields }: { roomName: string; fields?: Array<string> }): Promise<Room> {
-        assertRoomName(roomName);
-
-        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
-
-        return this._organizationApiClient
-            .request(`/rooms/${encodedDisplayName}`, {
-                method: "GET",
-                params: { includeOnlyLegacyRoomType: "false", ...(fields && { fields: fields.join(",") }) },
-            })
-            .then(
-                ({ data }) =>
-                    new Room(
-                        Object.assign({}, data, {
-                            roomName,
-                            ...(data.meeting && { meeting: Meeting.fromJson(data.meeting) }),
-                        })
-                    )
-            )
-            .catch((response) => {
-                if (response.status === 404) {
-                    return new Room({
-                        roomName,
-                        isClaimed: false,
-                        mode: "normal",
-                        product: {
-                            categoryName: "personal_free",
-                        },
-                        type: "personal",
-                        legacyRoomType: "free",
-                    });
-                }
-
-                if (response.status === 400 && response.data.error === "Banned room") {
-                    return new Room({ roomName, isBanned: true });
-                }
-
-                // Either server error or something else.
-                throw new Error(response.data ? response.data.error : "Could not fetch room information");
-            });
-    }
-
-    /**
-     * Claims the specified room.
-     *
-     * @param {Object} args
-     * @param {String} args.roomName - The roomName to claim
-     * @param {String} args.type - The type of room to claim
-     * @param {String} args.mode - The optional mode of room to claim
-     * @param {[Boolean]} args.isLocked - The optional lock status of room to claim
-     * @returns {Promise} - It will resolve with undefined.
-     */
-    claimRoom({ roomName, type, mode, isLocked }) {
-        assertRoomName(roomName);
-        assertString(type, "type");
-
-        return this._organizationApiClient
-            .request("/room/claim", {
-                method: "POST",
-                data: {
-                    roomName,
-                    type,
-                    ...(typeof mode === "string" && { mode }),
-                    ...(typeof isLocked === "boolean" && { isLocked }),
-                },
-            })
-            .then(() => undefined)
-            .catch((response) => {
-                throw new Error(response.data.error || "Failed to claim room");
-            });
-    }
-
-    /**
-     * Unclaims the specified room.
-     *
-     * @param {string} roomName - the room name to unclaim.
-     * @returns {Promise.<undefined>} - It will resolve with undefined.
-     */
-    unclaimRoom(roomName) {
-        assertRoomName(roomName);
-        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
-
-        return this._organizationApiClient
-            .request(`/room/${encodedDisplayName}`, {
-                method: "DELETE",
-            })
-            .then(() => undefined);
-    }
-
-    /**
-     * Changes the name of the room
-     *
-     * @param {Object} args
-     * @param {string} args.roomName - The name of the room to rename
-     * @param {string} args.newRoomName - The new name
-     * @returns {Promise<undefined>} - It will resolve if the room was renamed, reject for all other cases
-     */
-    renameRoom({ roomName, newRoomName }) {
-        assertRoomName(roomName);
-        assertString(newRoomName, "newRoomName");
-
-        const encodedRoomName = encodeURIComponent(roomName.substring(1));
-        return this._organizationApiClient
-
-            .request(`/room/${encodedRoomName}/roomName`, {
-                method: "PUT",
-                data: { newRoomName },
-            })
-            .then(() => undefined);
-    }
-
-    /**
-     * Changes the room mode (experimental)
-     *
-     * @param {string} roomName - The name of the room to change mode of
-     * @param {string} mode - The name of mode to set, currently only "group" is supported
-     * @returns {Promise<undefined>} - It will resolve if mode was changed, rejects for all other cases
-     */
-    changeMode({ roomName, mode }) {
-        assertRoomName(roomName);
-        assertString(mode, "mode");
-
-        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
-        return this._organizationApiClient
-
-            .request(`/room/${encodedDisplayName}/mode`, {
-                method: "PUT",
-                data: { mode },
-            })
-            .then(() => undefined);
-    }
-
-    /**
-     * Updates the room prefs
-     *
-     * @param {string} roomName - The name of the room to change mode of
-     * @param {object} preferences - The prefs you want to update and their values
-     * @returns {Promise<undefined>} - It will resolve if updated, rejects for all other cases
-     */
-    updatePreferences({ roomName, preferences }) {
-        assertRoomName(roomName);
-        assertInstanceOf(preferences, Object, "preferences");
-
-        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
-        return this._organizationApiClient
-            .request(`/room/${encodedDisplayName}/preferences`, {
-                method: "PATCH",
-                data: preferences,
-            })
-            .then(() => undefined);
-    }
-
-    /**
-     * Updates the protected room prefs
-     *
-     * @param {string} roomName - The name of the room to change mode of
-     * @param {object} preferences - The protected prefs you want to update and their values
-     * @returns {Promise<undefined>} - It will resolve if updated, rejects for all other cases
-     */
-    updateProtectedPreferences({ roomName, preferences }) {
-        assertRoomName(roomName);
-        assertInstanceOf(preferences, Object, "preferences");
-
-        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
-        return this._organizationApiClient
-            .request(`/room/${encodedDisplayName}/protected-preferences`, {
-                method: "PATCH",
-                data: preferences,
-            })
-            .then(() => undefined);
-    }
-
-    getRoomPermissions(roomName, { roomKey } = {}) {
-        assertRoomName(roomName);
-
-        return this._organizationApiClient
-            .request(createRoomUrl(roomName, "/permissions"), {
-                method: "GET",
-                ...(roomKey && { headers: { "X-Whereby-Room-Key": roomKey } }),
-            })
-            .then((response) => {
-                const { permissions, limits } = response.data;
-                return {
-                    permissions,
-                    limits,
-                };
-            });
-    }
-
-    /**
-     * Gets the specified room metrics
-     *
-     * @param {Object} args
-     * @param {string} args.roomName - The name of the room to get metrics from.
-     * @param {string} args.metrics - Comma-separated list of metrics to include.
-     * @param {string} args.from (optional) - Start time (inclusive) to count from in
-     * ISO format. Defaults to counting from the start of time.
-     * @param {string} args.to (optional) - End time (exclusive) to count up to in
-     * ISO format. Defaults to counting up to the current time.
-     * @returns {Promise<Object>} - It will resolve with the requested metrics.
-     */
-    getRoomMetrics({ roomName, metrics, from, to }) {
-        assertRoomName(roomName);
-        assertString(metrics, "metrics");
-
-        return this._organizationApiClient
-            .request(createRoomUrl(roomName, "/metrics"), {
-                method: "GET",
-                params: { metrics, from, to },
-            })
-            .then((response) => response.data);
-    }
-
-    /**
-     * Changes the room type
-     *
-     * @param {Object} args
-     * @param {string} args.roomName - The name of the room to change mode of
-     * @param {"personal" | "personal_xl"} args.type - Room type that should be set
-     * @returns {Promise<undefined>} - It will resolve if type was changed, rejects for all other cases
-     */
-    changeType({ roomName, type }) {
-        assertRoomName(roomName);
-        assertOneOf(type, ["personal", "personal_xl"], "type");
-
-        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
-        return this._organizationApiClient
-
-            .request(`/room/${encodedDisplayName}/type`, {
-                method: "PUT",
-                data: { type },
-            })
-            .then(() => undefined);
-    }
-
-    /** Gets a Forest campaign social image
-     *
-     * @param {Object} args
-     * @param {string} args.roomName - The name of the room to get metrics from.
-     * @param {number} args.count - Number to be displayed in the image as tree count.
-     * @returns {Promise<string>} - It will resolve with the image url.
-     */
-    getForestSocialImage({ roomName, count }) {
-        assertRoomName(roomName);
-        assertNumber(count, "count");
-
-        return this._organizationApiClient
-            .request(createRoomUrl(roomName, `/forest-social-image/${count}`), {
-                method: "GET",
-            })
-            .then((response) => response.data.imageUrl);
-    }
-}