@wazo/sdk 0.43.15 → 0.44.0

package/esm/simple/Phone.js

@@ -1,389 +0,0 @@
-import { SessionState } from 'sip.js/lib/api/session-state';
-import AdHocAPIConference from '../domain/AdHocAPIConference';
-import WebRTCPhone, * as PHONE_EVENTS from '../domain/Phone/WebRTCPhone';
-import { MESSAGE_TYPE_CHAT, MESSAGE_TYPE_SIGNAL } from '../domain/Phone/WebRTCPhone';
-import WebRTCClient, { events as clientEvents, transportEvents } from '../web-rtc-client';
-import IssueReporter from '../service/IssueReporter';
-import Emitter from '../utils/Emitter';
-import Wazo from './index';
-import SFUNotAvailableError from '../domain/SFUNotAvailableError';
-const logger = IssueReporter.loggerFor('simple-phone');
-const sipLogger = IssueReporter.loggerFor('sip.js');
-const protocolLogger = IssueReporter.loggerFor('sip');
-const protocolDebugMessages = ['Received WebSocket text message:', 'Sending WebSocket message:'];
-export class Phone extends Emitter {
-    client;
-    phone;
-    session;
-    sipLine;
-    SessionState;
-    ON_USER_AGENT;
-    ON_REGISTERED;
-    ON_UNREGISTERED;
-    ON_PROGRESS;
-    ON_CALL_ACCEPTED;
-    ON_CALL_ANSWERED;
-    ON_CALL_INCOMING;
-    ON_CALL_OUTGOING;
-    ON_CALL_MUTED;
-    ON_CALL_UNMUTED;
-    ON_CALL_RESUMED;
-    ON_CALL_HELD;
-    ON_CALL_UNHELD;
-    ON_CAMERA_DISABLED;
-    ON_CAMERA_RESUMED;
-    ON_CALL_CANCELED;
-    ON_CALL_FAILED;
-    ON_CALL_REJECTED;
-    ON_CALL_ENDED;
-    ON_CALL_ENDING;
-    ON_MESSAGE;
-    ON_REINVITE;
-    ON_TRACK;
-    ON_AUDIO_STREAM;
-    ON_VIDEO_STREAM;
-    ON_REMOVE_STREAM;
-    ON_SHARE_SCREEN_STARTED;
-    ON_SHARE_SCREEN_ENDING;
-    ON_SHARE_SCREEN_ENDED;
-    ON_TERMINATE_SOUND;
-    ON_PLAY_RING_SOUND;
-    ON_PLAY_INBOUND_CALL_SIGNAL_SOUND;
-    ON_PLAY_HANGUP_SOUND;
-    ON_PLAY_PROGRESS_SOUND;
-    ON_VIDEO_INPUT_CHANGE;
-    ON_CALL_ERROR;
-    ON_MESSAGE_TRACK_UPDATED;
-    ON_NETWORK_STATS;
-    ON_CHAT;
-    ON_SIGNAL;
-    ON_DISCONNECTED;
-    ON_EARLY_MEDIA;
-    MESSAGE_TYPE_CHAT;
-    MESSAGE_TYPE_SIGNAL;
-    constructor() {
-        super();
-        // Sugar syntax for `Wazo.Phone.EVENT_NAME`
-        Object.keys(PHONE_EVENTS).forEach((key) => {
-            // @ts-ignore: keys
-            this[key] = PHONE_EVENTS[key];
-        });
-        this.SessionState = SessionState;
-    }
-    async connect(rawOptions = {}, sipLine = null) {
-        const options = rawOptions;
-        if (this.phone) {
-            // Already connected
-            // let's update media constraints if they're being fed
-            if (options.media) {
-                this.phone.setMediaConstraints(options.media);
-            }
-            return;
-        }
-        const server = Wazo.Auth.getHost();
-        const session = Wazo.Auth.getSession();
-        if (!server || !session) {
-            throw new Error('Please connect to the server using `Wazo.Auth.logIn` or `Wazo.Auth.authenticate` before using Room.connect().');
-        }
-        this.session = session;
-        this.sipLine = sipLine || this.getPrimaryWebRtcLine();
-        if (!this.sipLine) {
-            throw new Error('Sorry, no sip lines found for this user');
-        }
-        options.userUuid = session.uuid || '';
-        this.connectWithCredentials(server, this.sipLine, session.displayName(), options);
-    }
-    connectWithCredentials(server, sipLine, displayName, rawOptions = {}) {
-        if (this.phone) {
-            // Already connected
-            return;
-        }
-        const [host, port = 443] = server.split(':');
-        const options = rawOptions;
-        options.media = options.media || {
-            audio: true,
-            video: false,
-        };
-        options.uaConfigOverrides = options.uaConfigOverrides || {};
-        if (IssueReporter.enabled) {
-            options.uaConfigOverrides.traceSip = true;
-            options.log = options.log || {};
-            options.log.builtinEnabled = false;
-            options.log.logLevel = 'debug';
-            options.log.connector = this._logConnector;
-        }
-        this.client = new WebRTCClient({
-            host,
-            port: typeof port === 'string' ? parseInt(port, 10) : port,
-            displayName,
-            authorizationUser: sipLine.username,
-            password: sipLine.secret,
-            uri: `${sipLine.username}@${server}`,
-            ...options,
-        }, undefined, options.uaConfigOverrides);
-        this.phone = new WebRTCPhone(this.client, options.audioDeviceOutput, true, options.audioDeviceRing);
-        this._transferEvents();
-    }
-    async disconnect() {
-        if (this.phone) {
-            if (this.phone.hasAnActiveCall()) {
-                logger.info('hangup call on disconnect');
-                await this.phone.hangup();
-            }
-            await this.phone.close();
-        }
-        this.phone = null;
-    }
-    // If audioOnly is set to true, all video stream will be deactivated, even remotes ones.
-    async call(extension, withCamera = false, rawSipLine = null, audioOnly = false, conference = false) {
-        if (!this.phone) {
-            return;
-        }
-        const sipLine = rawSipLine || this.getPrimaryWebRtcLine();
-        return this.phone.makeCall(extension, sipLine, withCamera, audioOnly, conference);
-    }
-    async hangup(callSession) {
-        logger.info('hangup via simple phone', {
-            callId: callSession.getId(),
-        });
-        return this.phone ? this.phone.hangup(callSession) : false;
-    }
-    async accept(callSession, cameraEnabled) {
-        logger.info('accept via simple phone', {
-            callId: callSession.getId(),
-            cameraEnabled,
-        });
-        return this.phone ? this.phone.accept(callSession, cameraEnabled) : null;
-    }
-    async startConference(host, otherCalls) {
-        const participants = [host, ...otherCalls].reduce((acc, participant) => {
-            acc[participant.getTalkingToIds()[0]] = participant;
-            return acc;
-        }, {});
-        if (!this.phone) {
-            return Promise.reject();
-        }
-        const adHocConference = new AdHocAPIConference({
-            phone: this.phone,
-            host,
-            participants,
-        });
-        return adHocConference.start();
-    }
-    mute(callSession, withApi = true) {
-        if (withApi) {
-            this.muteViaAPI(callSession);
-        }
-        this.phone?.mute(callSession);
-    }
-    unmute(callSession, withApi = true) {
-        if (withApi) {
-            this.unmuteViaAPI(callSession);
-        }
-        this.phone?.unmute(callSession);
-    }
-    muteViaAPI(callSession) {
-        if (callSession && callSession.callId) {
-            Wazo.getApiClient().calld.mute(callSession.callId).catch(e => {
-                logger.error('Mute via API, error', e);
-            });
-        }
-    }
-    unmuteViaAPI(callSession) {
-        if (callSession && callSession.callId) {
-            Wazo.getApiClient().calld.unmute(callSession.callId).catch(e => {
-                logger.error('Unmute via API, error', e);
-            });
-        }
-    }
-    hold(callSession) {
-        return this.phone?.hold(callSession, true);
-    }
-    async unhold(callSession) {
-        return this.phone?.unhold(callSession, true);
-    }
-    async resume(callSession) {
-        return this.phone?.resume(callSession) || null;
-    }
-    reject(callSession) {
-        return this.phone?.reject(callSession);
-    }
-    transfer(callSession, target) {
-        this.phone?.transfer(callSession, target);
-    }
-    atxfer(callSession) {
-        return this.phone?.atxfer(callSession) || null;
-    }
-    async reinvite(callSession, constraints = null, conference = false) {
-        return this.phone ? this.phone.sendReinvite(callSession, constraints, conference) : null;
-    }
-    async getStats(callSession) {
-        return this.phone ? this.phone.getStats(callSession) : null;
-    }
-    startNetworkMonitoring(callSession, interval = 1000) {
-        return this.phone ? this.phone.startNetworkMonitoring(callSession, interval) : null;
-    }
-    stopNetworkMonitoring(callSession) {
-        return this.phone ? this.phone.stopNetworkMonitoring(callSession) : null;
-    }
-    getSipSessionId(sipSession) {
-        if (!sipSession || !this.phone) {
-            return null;
-        }
-        return this.phone.getSipSessionId(sipSession);
-    }
-    sendMessage(body, sipSession, contentType = 'text/plain') {
-        const toSipSession = sipSession || this.getCurrentSipSession();
-        if (!toSipSession || !this.phone) {
-            return;
-        }
-        this.phone.sendMessage(toSipSession, body, contentType);
-    }
-    sendChat(content, sipSession) {
-        this.sendMessage(JSON.stringify({
-            type: MESSAGE_TYPE_CHAT,
-            content,
-        }), sipSession, 'application/json');
-    }
-    sendSignal(content, sipSession) {
-        this.sendMessage(JSON.stringify({
-            type: MESSAGE_TYPE_SIGNAL,
-            content,
-        }), sipSession, 'application/json');
-    }
-    turnCameraOff(callSession) {
-        this.phone?.turnCameraOff(callSession);
-    }
-    turnCameraOn(callSession) {
-        this.phone?.turnCameraOn(callSession);
-    }
-    async startScreenSharing(constraints, callSession) {
-        return this.phone?.startScreenSharing(constraints, callSession) || null;
-    }
-    stopScreenSharing(callSession, restoreLocalStream = true) {
-        return this.phone ? this.phone.stopScreenSharing(restoreLocalStream, callSession) : Promise.resolve();
-    }
-    sendDTMF(tone, callSession) {
-        this.phone?.sendKey(callSession, tone);
-    }
-    getLocalStream(callSession) {
-        return this.phone?.getLocalStream(callSession);
-    }
-    hasLocalVideo(callSession) {
-        return this.phone?.hasLocalVideo(callSession) || false;
-    }
-    hasALocalVideoTrack(callSession) {
-        return this.phone?.hasALocalVideoTrack(callSession) || false;
-    }
-    // @Deprecated
-    getLocalMediaStream(callSession) {
-        logger.warn('Phone.getLocalMediaStream is deprecated, use Phone.getLocalStream instead');
-        return this.phone?.getLocalStream(callSession);
-    }
-    getLocalVideoStream(callSession) {
-        return this.phone?.getLocalVideoStream(callSession) || null;
-    }
-    getRemoteStream(callSession) {
-        return this.phone?.getRemoteStream(callSession) || null;
-    }
-    getRemoteVideoStream(callSession) {
-        return this.phone?.getRemoteVideoStream(callSession) || null;
-    }
-    isVideoRemotelyHeld(callSession) {
-        return this.phone?.isVideoRemotelyHeld(callSession) || false;
-    }
-    // @Deprecated
-    getRemoteStreamForCall(callSession) {
-        logger.warn('Phone.getRemoteStreamForCall is deprecated, use Phone.getRemoteStream instead');
-        return this.getRemoteStream(callSession) || null;
-    }
-    // Returns remote streams directly from the peerConnection
-    // @Deprecated
-    getRemoteStreamsForCall(callSession) {
-        logger.warn('Phone.getRemoteStreamsForCall is deprecated, use Phone.getLocalStream instead');
-        return this.getLocalStream(callSession) || null;
-    }
-    // @Deprecated
-    getRemoteVideoStreamForCall(callSession) {
-        logger.warn('Phone.getRemoteVideoStreamForCall is deprecated, use Phone.getRemoteVideoStream instead');
-        return this.getRemoteVideoStream(callSession);
-    }
-    //  Useful in a react-native environment when remoteMediaStream is not updated
-    getRemoteVideoStreamFromPc(callSession) {
-        return this.phone?.getRemoteVideoStreamFromPc(callSession) || null;
-    }
-    hasVideo(callSession) {
-        return this.phone ? this.phone.hasVideo(callSession) : false;
-    }
-    hasAVideoTrack(callSession) {
-        return this.phone ? this.phone.hasAVideoTrack(callSession) : false;
-    }
-    getCurrentSipSession() {
-        return this.phone?.currentSipSession || null;
-    }
-    getPrimaryWebRtcLine() {
-        const session = Wazo.Auth.getSession();
-        return session?.primaryWebRtcLine() || null;
-    }
-    getOutputDevice() {
-        return this.phone?.audioOutputDeviceId || null;
-    }
-    getPrimaryLine() {
-        const session = Wazo.Auth.getSession();
-        return session?.primarySipLine() || null;
-    }
-    getLineById(lineId) {
-        return this.getSipLines().find(line => line && line.id === lineId) || null;
-    }
-    getSipLines() {
-        const session = Wazo.Auth.getSession();
-        if (!session) {
-            return [];
-        }
-        return session.profile?.sipLines || [];
-    }
-    hasSfu() {
-        return this.sipLine?.hasVideoConference() || false;
-    }
-    checkSfu() {
-        if (!this.hasSfu()) {
-            throw new SFUNotAvailableError();
-        }
-    }
-    enableLogger() {
-        this.client.enableLogger(this._logConnector);
-    }
-    _transferEvents() {
-        this.unbind();
-        [...clientEvents, ...transportEvents].forEach(event => {
-            this.client.on(event, (...args) => this.eventEmitter.emit.apply(this.eventEmitter.emit, [`client-${event}`, ...args]));
-        });
-        Object.values(PHONE_EVENTS).forEach(event => {
-            if (typeof event !== 'string' || !this.phone) {
-                return;
-            }
-            this.phone.on(event, (...args) => this.eventEmitter.emit.apply(this.eventEmitter, [event, ...args]));
-        });
-    }
-    _logConnector(level, className, label, content) {
-        const protocolIndex = content && content.indexOf ? protocolDebugMessages.findIndex(prefix => content.indexOf(prefix) !== -1) : -1;
-        if (className === 'sip.Transport' && protocolIndex !== -1) {
-            const direction = protocolIndex === 0 ? 'receiving' : 'sending';
-            const message = content.replace(`${protocolDebugMessages[protocolIndex]}\n\n`, '').replace('\r\n', '\n');
-            protocolLogger.trace(message, {
-                className,
-                direction,
-            });
-        }
-        else {
-            sipLogger.trace(content, {
-                className,
-            });
-        }
-    }
-}
-if (!global.wazoTelephonyInstance) {
-    global.wazoTelephonyInstance = new Phone();
-}
-// @ts-ignore: Circular definition of import alias 'default'.
-export default global.wazoTelephonyInstance;

package/esm/simple/Websocket.js

@@ -1,81 +0,0 @@
-import WazoWebSocketClient, * as WebSocketClient from '../websocket-client';
-import Emitter from '../utils/Emitter';
-import IssueReporter from '../service/IssueReporter';
-import { obfuscateToken } from '../utils/string';
-const { SOCKET_EVENTS, ...OTHER_EVENTS } = WebSocketClient;
-const ALL_EVENTS = [...Object.values(SOCKET_EVENTS), ...Object.values(OTHER_EVENTS)];
-const logger = IssueReporter.loggerFor('simple-ws-client');
-export class Websocket extends Emitter {
-    ws;
-    eventLists;
-    CONFERENCE_USER_PARTICIPANT_JOINED;
-    CONFERENCE_USER_PARTICIPANT_LEFT;
-    MEETING_USER_PARTICIPANT_JOINED;
-    MEETING_USER_PARTICIPANT_LEFT;
-    CALL_CREATED;
-    constructor() {
-        super();
-        // Sugar syntax for `Wazo.WebSocket.EVENT_NAME`
-        Object.keys(OTHER_EVENTS).forEach(key => {
-            // @ts-ignore: keys
-            this[key] = OTHER_EVENTS[key];
-        });
-        Object.keys(SOCKET_EVENTS).forEach(key => {
-            // @ts-ignore: keys
-            this[key] = SOCKET_EVENTS[key];
-        });
-        this.eventLists = WazoWebSocketClient.eventLists;
-        this.ws = null;
-    }
-    open(host, session) {
-        logger.info('open simple WebSocket', {
-            host,
-            token: obfuscateToken(session.token),
-        });
-        this.ws = new WazoWebSocketClient({
-            host,
-            token: session.token,
-            events: ['*'],
-            version: 2,
-            session,
-        }, {
-            rejectUnauthorized: false,
-            binaryType: 'arraybuffer',
-        });
-        this.ws.connect();
-        // Re-emit all events
-        ALL_EVENTS.forEach((event) => {
-            if (!this.ws) {
-                return;
-            }
-            this.ws.on(event, (payload) => {
-                this.eventEmitter.emit(event, payload);
-            });
-        });
-    }
-    updateToken(token) {
-        logger.info('update token via simple Websocket', {
-            token,
-            ws: !!this.ws,
-        });
-        if (!this.ws) {
-            return;
-        }
-        this.ws.updateToken(token);
-    }
-    isOpen() {
-        return this.ws?.isConnected() || false;
-    }
-    close(force = false) {
-        logger.info('Closing event transport websocket', { force, ws: !!this.ws });
-        if (this.ws) {
-            this.ws.close(force);
-        }
-        this.unbind();
-    }
-}
-if (!global.wazoWebsocketInstance) {
-    global.wazoWebsocketInstance = new Websocket();
-}
-// @ts-ignore: Circular definition of import alias 'default'.
-export default global.wazoWebsocketInstance;

package/esm/simple/__tests__/Auth.test.js

@@ -1,144 +0,0 @@
-import BadResponse from '../../domain/BadResponse';
-import ServerError from '../../domain/ServerError';
-import getApiClient, { setRefreshToken } from '../../service/getApiClient';
-import { Auth as AuthClass } from '../Auth';
-const Auth = new AuthClass();
-const TOKEN = 'some-token';
-const REFRESH_TOKEN = 'some-refresh-token';
-const USER_UUID = 'some-user-uuid';
-jest.mock('../../service/getApiClient');
-describe('simple/Auth', () => {
-    beforeEach(() => {
-        const authenticate = jest.fn();
-        getApiClient.mockImplementation(() => ({
-            auth: {
-                authenticate,
-            },
-        }));
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    describe('validateToken', () => {
-        it('should return undefined if nullish', async () => {
-            // @ts-expect-error
-            const result = await Auth.validateToken(null);
-            expect(result).toEqual(undefined);
-        });
-        it('should set refresh token if provided', async () => {
-            await Auth.validateToken(TOKEN, REFRESH_TOKEN);
-            expect(setRefreshToken).toHaveBeenCalledWith(REFRESH_TOKEN);
-        });
-        it('should set user uuid header when using edge server', async () => {
-            Auth.usingEdgeServer = true;
-            const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
-            await Auth.validateToken(TOKEN, undefined, USER_UUID);
-            expect(setHttpUserUuidHeader).toHaveBeenCalledWith(USER_UUID);
-        });
-        it('should NOT set user uuid header when NOT using edge server', async () => {
-            Auth.usingEdgeServer = false;
-            const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
-            await Auth.validateToken(TOKEN, undefined, USER_UUID);
-            expect(setHttpUserUuidHeader).not.toHaveBeenCalled();
-        });
-    });
-    describe('checkHttpUserUuidHeader', () => {
-        it('should return undefined if UUID is null', async () => {
-            const result = await Auth.checkHttpUserUuidHeader(null);
-            expect(result).toEqual(undefined);
-        });
-        it('should set user UUID header on successful HEAD call', async () => {
-            const head = jest.fn(() => Promise.resolve({ headers: { get: () => null } }));
-            const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
-            Auth.onSetUsingEdgeServer = jest.fn();
-            getApiClient.mockImplementation(() => ({
-                client: {
-                    head,
-                },
-            }));
-            await Auth.checkHttpUserUuidHeader(USER_UUID);
-            expect(head).toHaveBeenCalled();
-            expect(setHttpUserUuidHeader).toHaveBeenCalledWith(USER_UUID);
-            expect(Auth.usingEdgeServer).toEqual(true);
-            expect(Auth.onSetUsingEdgeServer).toHaveBeenCalledWith(true);
-        });
-        it('should NOT set user UUID header on failed HEAD call', async () => {
-            const head = jest.fn(() => Promise.reject());
-            const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
-            Auth.onSetUsingEdgeServer = jest.fn();
-            getApiClient.mockImplementation(() => ({
-                client: {
-                    head,
-                },
-            }));
-            await Auth.checkHttpUserUuidHeader(USER_UUID);
-            expect(head).toHaveBeenCalled();
-            expect(setHttpUserUuidHeader).not.toHaveBeenCalled();
-            expect(Auth.usingEdgeServer).toEqual(false);
-            expect(Auth.onSetUsingEdgeServer).toHaveBeenCalledWith(false);
-        });
-        it('should set user UUID header on mobile when header is present', async () => {
-            Auth.mobile = true;
-            const head = jest.fn(() => Promise.resolve({ headers: { get: () => 'X-User-UUID: something' } }));
-            const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
-            Auth.onSetUsingEdgeServer = jest.fn();
-            getApiClient.mockImplementation(() => ({
-                client: {
-                    head,
-                },
-            }));
-            await Auth.checkHttpUserUuidHeader(USER_UUID);
-            expect(head).toHaveBeenCalled();
-            expect(setHttpUserUuidHeader).toHaveBeenCalledWith(USER_UUID);
-            expect(Auth.usingEdgeServer).toEqual(true);
-            expect(Auth.onSetUsingEdgeServer).toHaveBeenCalledWith(true);
-        });
-        it('should NOT set user UUID header on mobile when header is NOT present', async () => {
-            Auth.mobile = true;
-            const head = jest.fn(() => Promise.resolve({ headers: { get: () => 'something' } }));
-            const setHttpUserUuidHeader = jest.spyOn(Auth, 'setHttpUserUuidHeader');
-            Auth.onSetUsingEdgeServer = jest.fn();
-            getApiClient.mockImplementation(() => ({
-                client: {
-                    head,
-                },
-            }));
-            await Auth.checkHttpUserUuidHeader(USER_UUID);
-            expect(head).toHaveBeenCalled();
-            expect(setHttpUserUuidHeader).not.toHaveBeenCalled();
-            expect(Auth.usingEdgeServer).toEqual(false);
-            expect(Auth.onSetUsingEdgeServer).toHaveBeenCalledWith(false);
-        });
-    });
-    describe('initiateIdpAuthentication', () => {
-        const validResponse = { location: 'idp.com/auth', saml_session_id: 'a1b2C3d4' };
-        it('should return a `location` and `saml_session_id` if the response is valid', async () => {
-            const initiateIdpAuthentication = jest.fn(() => validResponse);
-            getApiClient.mockImplementation(() => ({
-                auth: {
-                    initiateIdpAuthentication,
-                },
-            }));
-            const response = await Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz');
-            expect(response).toBe(validResponse);
-        });
-        it('should return a `NoSamlRouteError` if the response is a 404', async () => {
-            const initiateIdpAuthentication = jest.fn(() => { throw BadResponse.fromText('an error message', 404); });
-            getApiClient.mockImplementation(() => ({
-                auth: {
-                    initiateIdpAuthentication,
-                },
-            }));
-            await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('No route found for SAML SSO');
-        });
-        it('should return a `SamlConfigError` if the response is a 500', async () => {
-            const initiateIdpAuthentication = jest.fn(() => { throw ServerError.fromText('an error message', 500); });
-            getApiClient.mockImplementation(() => ({
-                auth: {
-                    initiateIdpAuthentication,
-                },
-            }));
-            await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('SAML/server configuration error');
-        });
-    });
-});