@wazo/sdk 0.43.15 → 0.44.1

package/esm/api/dird.js

@@ -1,110 +0,0 @@
-import { jsonToGraphQLQuery } from 'json-to-graphql-query/lib/jsonToGraphQLQuery';
-import ApiRequester from '../utils/api-requester';
-import { Contact } from '../index';
-const getContactPayload = (contact) => ({
-    email: contact.email,
-    firstname: contact.firstName ? contact.firstName : '',
-    lastname: contact.lastName ? contact.lastName : '',
-    number: contact.phoneNumber ? contact.phoneNumber : '',
-    entreprise: contact.entreprise ? contact.entreprise : '',
-    birthday: contact.birthday ? contact.birthday : '',
-    address: contact.address ? contact.address : '',
-    note: contact.note ? contact.note : '',
-});
-export default ((client, baseUrl) => ({
-    search: (context, term, offset = 0, limit = null) => client.get(`${baseUrl}/directories/lookup/${context}`, {
-        term,
-    }).then((response) => Contact.parseMany(response, offset, limit)),
-    listPersonalContacts: (queryParams) => client.get(`${baseUrl}/personal`, queryParams).then((response) => Contact.parseManyPersonal(response.items)),
-    fetchPersonalContact: (contactUuid) => client.get(`${baseUrl}/personal/${contactUuid}`).then(Contact.parsePersonal),
-    addContact: (contact) => client.post(`${baseUrl}/personal`, getContactPayload(contact)).then(Contact.parsePersonal),
-    editContact: (contact) => client.put(`${baseUrl}/personal/${contact.sourceId || contact.id || ''}`, getContactPayload(contact)).then(Contact.parsePersonal),
-    importContacts: async (csv) => {
-        const headers = {
-            'Content-Type': 'text/csv; charset=utf-8',
-            'X-Auth-Token': client.token,
-        };
-        return client.post(`${baseUrl}/personal/import`, csv, headers).then((result) => Contact.parseManyPersonal(result.created));
-    },
-    deleteContact: (contactUuid) => client.delete(`${baseUrl}/personal/${contactUuid}`),
-    listFavorites: (context) => client.get(`${baseUrl}/directories/favorites/${context}`).then(Contact.parseMany),
-    markAsFavorite: (source, sourceId) => {
-        const url = `${baseUrl}/directories/favorites/${source}/${sourceId}`;
-        return client.put(url, null, null, ApiRequester.successResponseParser);
-    },
-    removeFavorite: (source, sourceId) => client.delete(`${baseUrl}/directories/favorites/${source}/${sourceId}`),
-    fetchOffice365Source: (context) => client.get(`${baseUrl}/directories/${context}/sources`, {
-        backend: 'office365',
-    }),
-    fetchOffice365Contacts: async (source, queryParams) => {
-        if (!source) {
-            return Promise.resolve([]);
-        }
-        return client.get(`${baseUrl}/backends/office365/sources/${source.uuid}/contacts`, queryParams).then((response) => Contact.parseManyOffice365(response.items, source));
-    },
-    fetchWazoSource: (context) => client.get(`${baseUrl}/directories/${context}/sources`, {
-        backend: 'wazo',
-    }),
-    // Can be used with `queryParams = { uuid: uuid1, uuid2 }` to fetch multiple contacts
-    fetchWazoContacts: async (source, queryParams) => {
-        if (!source) {
-            return Promise.resolve([]);
-        }
-        return client.get(`${baseUrl}/backends/wazo/sources/${source.uuid}/contacts`, queryParams).then((response) => Contact.parseManyWazo(response.items, source));
-    },
-    fetchGoogleSource: (context) => client.get(`${baseUrl}/directories/${context}/sources`, {
-        backend: 'google',
-    }),
-    fetchGoogleContacts: async (source, queryParams) => {
-        if (!source) {
-            return Promise.resolve([]);
-        }
-        return client.get(`${baseUrl}/backends/google/sources/${source.uuid}/contacts`, queryParams).then((response) => Contact.parseManyGoogle(response.items, source));
-    },
-    fetchConferenceSource: (context) => client.get(`${baseUrl}/directories/${context}/sources`, {
-        backend: 'conference',
-    }),
-    fetchSourcesFor: (context, backend) => client.get(`${baseUrl}/directories/${context}/sources`, { backend }),
-    fetchPhonebookContacts: async (source, queryParams) => {
-        if (!source) {
-            return Promise.resolve({ items: [], total: 0 });
-        }
-        return client.get(`${baseUrl}/backends/phonebook/sources/${source.uuid}/contacts`, queryParams);
-    },
-    fetchConferenceContacts: async (source, queryParams) => {
-        if (!source) {
-            return Promise.resolve([]);
-        }
-        return client.get(`${baseUrl}/backends/conference/sources/${source.uuid}/contacts`, queryParams).then((response) => Contact.parseManyConference(response.items, source));
-    },
-    // Graphql
-    findMultipleContactsByNumber: (numbers, fields) => {
-        const query = jsonToGraphQLQuery({
-            me: {
-                contacts: {
-                    __args: {
-                        profile: 'default',
-                        extens: numbers,
-                    },
-                    edges: {
-                        node: fields || {
-                            firstname: true,
-                            lastname: true,
-                            wazoReverse: true,
-                            wazoBackend: true,
-                            email: true,
-                            wazoSourceEntryId: true,
-                            wazoSourceName: true,
-                            '... on WazoContact': {
-                                userUuid: true,
-                            },
-                        },
-                    },
-                },
-            },
-        });
-        return client.post(`${baseUrl}/graphql`, {
-            query: `{${query}}`,
-        }).then(Contact.manyGraphQlWithNumbersParser(numbers));
-    },
-}));

package/esm/api/webhookd.js

@@ -1,7 +0,0 @@
-import Subscription from '../domain/Subscription';
-export default ((client, baseUrl) => ({
-    getSubscriptions: () => client.get(`${baseUrl}/users/me/subscriptions`).then(Subscription.parseMany),
-    getSubscription: (uuid) => client.get(`${baseUrl}/users/me/subscriptions/${uuid}`).then(Subscription.parse),
-    createSubscription: (payload) => client.post(`${baseUrl}/users/me/subscriptions`, payload),
-    removeSubscription: (uuid) => client.delete(`${baseUrl}/users/me/subscriptions/${uuid}`),
-}));

package/esm/api-client.js

@@ -1,41 +0,0 @@
-import applicationMethods from './api/application';
-import confdMethods from './api/confd';
-import ctidNgMethods from './api/ctid-ng';
-import dirdMethods from './api/dird';
-import callLogdMethods from './api/call-logd';
-import chatdMethods from './api/chatd';
-import calldMethods from './api/calld';
-import agentdMethods from './api/agentd';
-import webhookdMethods from './api/webhookd';
-import amidMethods from './api/amid';
-import { APPLICATION_VERSION, CONFD_VERSION, CTIDNG_VERSION, DIRD_VERSION, CALL_LOGD_VERSION, CHATD_VERSION, CALLD_VERSION, AGENTD_VERSION, WEBHOOKD_VERSION, AMID_VERSION, } from './constants';
-import BaseApiClient from './base-api-client';
-export default class ApiClient extends BaseApiClient {
-    application;
-    confd;
-    ctidNg;
-    dird;
-    callLogd;
-    chatd;
-    calld;
-    agentd;
-    webhookd;
-    amid;
-    constructor(args) {
-        super(args);
-        this.initializeEndpoints(); // Reinitialize sdk endpoints
-    }
-    initializeEndpoints() {
-        super.initializeEndpoints();
-        this.application = applicationMethods(this.client, `calld/${APPLICATION_VERSION}/applications`);
-        this.confd = confdMethods(this.client, `confd/${CONFD_VERSION}`);
-        this.ctidNg = ctidNgMethods(this.client, `ctid-ng/${CTIDNG_VERSION}`);
-        this.dird = dirdMethods(this.client, `dird/${DIRD_VERSION}`);
-        this.callLogd = callLogdMethods(this.client, `call-logd/${CALL_LOGD_VERSION}`);
-        this.chatd = chatdMethods(this.client, `chatd/${CHATD_VERSION}`);
-        this.calld = calldMethods(this.client, `calld/${CALLD_VERSION}`);
-        this.agentd = agentdMethods(this.client, `agentd/${AGENTD_VERSION}`);
-        this.webhookd = webhookdMethods(this.client, `webhookd/${WEBHOOKD_VERSION}`);
-        this.amid = amidMethods(this.client, `amid/${AMID_VERSION}`);
-    }
-}

package/esm/base-api-client.js

@@ -1,125 +0,0 @@
-import authMethods from './api/auth';
-import ApiRequester from './utils/api-requester';
-import IssueReporter from './service/IssueReporter';
-import { obfuscateToken } from './utils/string';
-import { AUTH_VERSION } from './constants';
-const logger = IssueReporter ? IssueReporter.loggerFor('api') : console;
-export default class BaseApiClient {
-    client;
-    auth;
-    refreshToken;
-    onRefreshToken;
-    onRefreshTokenError;
-    refreshExpiration;
-    refreshBackend;
-    refreshTenantId;
-    refreshDomainName;
-    isMobile;
-    fetchOptions;
-    constructor({ server, agent = null, refreshToken, clientId, isMobile = false, fetchOptions, }) {
-        this.updateParameters({
-            server,
-            agent,
-            clientId,
-            fetchOptions,
-        });
-        this.refreshToken = refreshToken;
-        this.isMobile = isMobile || false;
-    }
-    initializeEndpoints() {
-        this.auth = authMethods(this.client, `auth/${AUTH_VERSION}`);
-    }
-    updateParameters({ server, agent, clientId, fetchOptions, }) {
-        const refreshTokenCallback = this.refreshTokenCallback.bind(this);
-        this.client = new ApiRequester({
-            server,
-            agent,
-            refreshTokenCallback,
-            clientId,
-            fetchOptions,
-        });
-        this.initializeEndpoints();
-    }
-    async forceRefreshToken() {
-        logger.info('forcing refresh token, calling callback');
-        return this.refreshTokenCallback();
-    }
-    async refreshTokenCallback() {
-        logger.info('refresh token callback called', {
-            refreshToken: obfuscateToken(this.refreshToken),
-            refreshBackend: this.refreshBackend,
-            refreshTenantId: this.refreshTenantId,
-            refreshDomainName: this.refreshDomainName,
-            refreshExpiration: this.refreshExpiration,
-            isMobile: this.isMobile,
-        });
-        if (!this.refreshToken) {
-            return null;
-        }
-        try {
-            const session = await this.auth.refreshToken(this.refreshToken, this.refreshBackend, this.refreshExpiration, this.isMobile, this.refreshTenantId, this.refreshDomainName);
-            if (!session) {
-                return null;
-            }
-            logger.info('token refreshed', {
-                token: obfuscateToken(session.token),
-            });
-            if (this.onRefreshToken) {
-                this.onRefreshToken(session.token, session);
-            }
-            this.setToken(session.token);
-            return session.token;
-        }
-        catch (error) {
-            logger.error('token refresh, error', error);
-            if (this.onRefreshTokenError) {
-                this.onRefreshTokenError(error);
-            }
-        }
-        return null;
-    }
-    setToken(token) {
-        this.client.setToken(token);
-    }
-    setTenant(tenant) {
-        this.client.setTenant(tenant);
-    }
-    setRefreshToken(refreshToken) {
-        this.refreshToken = refreshToken;
-    }
-    setRequestTimeout(requestTimeout) {
-        this.client.setRequestTimeout(requestTimeout);
-    }
-    setClientId(clientId) {
-        this.client.clientId = clientId;
-    }
-    setOnRefreshToken(onRefreshToken) {
-        this.onRefreshToken = onRefreshToken;
-    }
-    setOnRefreshTokenError(callback) {
-        this.onRefreshTokenError = callback;
-    }
-    setRefreshExpiration(refreshExpiration) {
-        this.refreshExpiration = refreshExpiration;
-    }
-    setRefreshBackend(refreshBackend) {
-        this.refreshBackend = refreshBackend;
-    }
-    setRefreshTenantId(tenantId) {
-        console.warn('Use of `setRefreshTenantId` is deprecated, use `setRefreshDomainName` instead');
-        this.refreshTenantId = tenantId;
-    }
-    setRefreshDomainName(domainName) {
-        this.refreshDomainName = domainName;
-    }
-    setIsMobile(isMobile) {
-        this.isMobile = isMobile;
-    }
-    setFetchOptions(fetchOptions) {
-        this.fetchOptions = fetchOptions;
-        this.client.setFetchOptions(fetchOptions);
-    }
-    disableErrorLogging() {
-        this.client.disableErrorLogging();
-    }
-}

package/esm/checker/Checker.js

@@ -1,54 +0,0 @@
-import WazoApiClient from '../api-client';
-import IssueReporter from '../service/IssueReporter';
-import checks from './checks/index';
-const logger = IssueReporter.loggerFor('engine-check');
-class Checker {
-    session;
-    server;
-    externalAppConfig;
-    checks;
-    constructor(server, session, externalAppConfig = {}) {
-        this.server = server;
-        this.session = session;
-        this.externalAppConfig = externalAppConfig;
-        this.checks = [...checks];
-    }
-    async check(onCheckBegin = () => { }, onCheckResult = () => { }) {
-        await this._addEngineVersion();
-        logger.info('Engine check starting');
-        for (let i = 0; i < this.checks.length; i++) {
-            const { name, check, } = this.checks[i];
-            logger.info(`Checking ${name} ...`);
-            onCheckBegin(name);
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                const result = await check(this.server, this.session, this.externalAppConfig);
-                logger.info(`Checking ${name} success.`, {
-                    result,
-                });
-                onCheckResult(name, result);
-            }
-            catch (e) {
-                logger.info(`Checking ${name} failure`, {
-                    message: e.message,
-                });
-                onCheckResult(name, e);
-            }
-        }
-        logger.info('Engine check done.');
-    }
-    addCheck(check) {
-        this.checks.push(check);
-    }
-    async _addEngineVersion() {
-        if (!this.session.engineVersion) {
-            const apiClient = new WazoApiClient({
-                server: this.server,
-            });
-            apiClient.setToken(this.session.token);
-            const { wazo_version: engineVersion, } = await apiClient.confd.getInfos();
-            this.session.engineVersion = engineVersion;
-        }
-    }
-}
-export default Checker;

package/esm/checker/checks/aor.js

@@ -1,28 +0,0 @@
-import WazoApiClient from '../../api-client';
-export default {
-    name: 'List of AOR',
-    check: async (server, session) => {
-        const apiClient = new WazoApiClient({
-            server,
-        });
-        apiClient.setToken(session.token);
-        apiClient.disableErrorLogging();
-        const line = session.primaryWebRtcLine();
-        if (!line) {
-            return 'No WebRTC line for this user';
-        }
-        const { username, } = line;
-        try {
-            const aors = await apiClient.amid.getAors(username);
-            const nbAors = aors.length;
-            const availableAors = aors.filter(aor => aor.status === 'Reachable');
-            return `Number of AOR: ${nbAors} (${availableAors.length} Avail, ${nbAors - availableAors.length} Unavail)`;
-        }
-        catch (e) {
-            if (e.status === 401) {
-                return 'Not available for this user';
-            }
-            throw e;
-        }
-    },
-};

package/esm/checker/checks/api.js

@@ -1,76 +0,0 @@
-import WazoApiClient from '../../api-client';
-import ServerError from '../../domain/ServerError';
-export default {
-    name: 'API',
-    check: async (server, session) => {
-        const client = new WazoApiClient({
-            server,
-        });
-        client.setToken(session.token);
-        client.disableErrorLogging();
-        const handleApiError = (apiName, error) => {
-            const statusText = error instanceof ServerError ? 'server error' : 'api error';
-            throw new Error(`${apiName} fails with status (${error.status}, ${statusText}) : ${error.message}`);
-        };
-        // Check simple API call
-        try {
-            await client.auth.getPushNotificationSenderId(session.uuid);
-            await client.auth.getProviders(session.uuid);
-        }
-        catch (e) {
-            handleApiError('wazo-auth', e);
-        }
-        try {
-            await client.callLogd.listCallLogs();
-        }
-        catch (e) {
-            handleApiError('wazo-callogd', e);
-        }
-        try {
-            await client.calld.listCalls();
-        }
-        catch (e) {
-            handleApiError('wazo-calld', e);
-        }
-        try {
-            await client.calld.listVoicemails();
-        }
-        catch (e) {
-            // API throws a 404 when no voicemail
-            if (e.status !== 404) {
-                handleApiError('wazo-calld', e);
-            }
-        }
-        try {
-            await client.chatd.getState(session.uuid);
-            await client.chatd.getContactStatusInfo(session.uuid);
-            await client.chatd.getUserRooms();
-        }
-        catch (e) {
-            handleApiError('wazo-chatd', e);
-        }
-        try {
-            await client.confd.getInfos();
-            await client.confd.getUser(session.uuid);
-        }
-        catch (e) {
-            handleApiError('wazo-confd', e);
-        }
-        try {
-            await client.dird.listPersonalContacts();
-            await client.dird.listFavorites(session.primaryContext());
-            await client.dird.fetchWazoSource(session.primaryContext());
-            const conferenceSource = await client.dird.fetchConferenceSource(session.primaryContext());
-            await client.dird.fetchConferenceContacts(conferenceSource.items[0]);
-        }
-        catch (e) {
-            handleApiError('wazo-dird', e);
-        }
-        try {
-            await client.webhookd.getSubscriptions();
-        }
-        catch (e) {
-            handleApiError('wazo-webhookd', e);
-        }
-    },
-};

package/esm/checker/checks/ice-ipv4.js

@@ -1,69 +0,0 @@
-/* global MediaStream, RTCPeerConnection */
-import { parseCandidate } from '../../utils/webrtc';
-import isMobile from '../../utils/isMobile';
-const checkIsIPV4 = (ip) => {
-    const blocks = ip.split('.');
-    if (blocks.length !== 4) {
-        return false;
-    }
-    return blocks.every(block => parseInt(block, 10) >= 0 && parseInt(block, 10) <= 255);
-};
-export default {
-    name: 'Non IP v4 ice',
-    check: (server, session, externalAppConfig) => new Promise((resolve, reject) => {
-        if (typeof MediaStream === 'undefined') {
-            resolve('Skipped on node');
-            return;
-        }
-        const mobile = isMobile();
-        const offerOptions = {
-            offerToReceiveAudio: 1,
-        };
-        const ips = [];
-        const config = {
-            iceServers: [{
-                    urls: 'stun:stun1.l.google.com:19302',
-                }, {
-                    urls: 'stun:stun2.l.google.com:19302',
-                }],
-        };
-        let hasSrflxOrRelay = false;
-        if (externalAppConfig && externalAppConfig.stun_servers) {
-            config.iceServers = { ...externalAppConfig.stun_servers.split(',').map((url) => ({
-                    urls: url,
-                })),
-                ...config.iceServers, };
-        }
-        if (externalAppConfig && externalAppConfig.turn_servers) {
-            config.iceServers = [...JSON.parse(externalAppConfig.turn_servers), ...(config.iceServers || [])];
-            // Force to use TURN when defined in config
-            config.iceTransportPolicy = 'relay';
-        }
-        const pc = new RTCPeerConnection(config);
-        pc.createDataChannel('wazo-check-ipv4');
-        pc.onicecandidate = e => {
-            if (e.candidate) {
-                const rawCandidate = e.candidate.candidate;
-                if (rawCandidate.indexOf('srflx') !== -1 || rawCandidate.indexOf('relay') !== -1) {
-                    hasSrflxOrRelay = true;
-                    const candidate = parseCandidate(e.candidate.candidate);
-                    ips.push(candidate.ip);
-                }
-            }
-            else if (!e.candidate) {
-                if (!hasSrflxOrRelay) {
-                    return reject(new Error('No `srflx` or `relay` found in candidate. Please consider using a TURN server.'));
-                }
-                if (ips.every(checkIsIPV4)) {
-                    resolve(null);
-                }
-                else {
-                    const nonIPV4 = ips.find(ip => !checkIsIPV4(ip));
-                    reject(new Error(`Non IPv4 ice candidate found : ${nonIPV4}.`));
-                }
-            }
-        };
-        // @ts-ignore
-        pc.createOffer(offerOptions).then(offer => pc.setLocalDescription(offer)).then(description => (mobile ? pc.createOffer(offerOptions) : description)).then(sessionDescription => (mobile ? pc.setLocalDescription(sessionDescription) : sessionDescription));
-    }),
-};

package/esm/checker/checks/index.js

@@ -1,8 +0,0 @@
-import api from './api';
-import aor from './aor';
-import wazoWebsocket from './wazo-websocket';
-import webrtcTransport from './webrtc-transport';
-import webrtc from './webrtc';
-import SymmetricNat from './symmetric-nat';
-import iceIpv4 from './ice-ipv4';
-export default [aor, api, wazoWebsocket, webrtcTransport, webrtc, SymmetricNat, iceIpv4];

package/esm/checker/checks/symmetric-nat.js

@@ -1,59 +0,0 @@
-/* global MediaStream, RTCPeerConnection */
-import { parseCandidate } from '../../utils/webrtc';
-const timeoutDuration = 8000; // @see https://webrtchacks.com/symmetric-nat/
-export default {
-    name: 'Symmetric NAT',
-    check: () => new Promise((resolve, reject) => {
-        if (typeof MediaStream === 'undefined') {
-            return resolve('Skipped on node');
-        }
-        const candidates = {};
-        const rawCandidates = [];
-        let nbCandidates = 0;
-        const pc = new RTCPeerConnection({
-            iceServers: [{
-                    urls: 'stun:stun.wazo.io:443',
-                }, {
-                    urls: 'stun:stun1.l.google.com:19302',
-                }, {
-                    urls: 'stun:stun2.l.google.com:19302',
-                }],
-        });
-        let timeout;
-        const onEnded = () => {
-            clearTimeout(timeout);
-            if (Object.keys(candidates).length === 0) {
-                reject(new Error(`Timed out (${timeoutDuration}ms), ${nbCandidates} candidates : ${rawCandidates.join(', ')}`));
-                return;
-            }
-            const ports = candidates[Object.keys(candidates)[0]];
-            if (ports.length === 1) {
-                resolve();
-            }
-            else {
-                reject(new Error('Symmetric NAT detected, you should use a TURN server.'));
-            }
-        };
-        timeout = setTimeout(onEnded, timeoutDuration);
-        pc.createDataChannel('wazo-check-nat');
-        pc.onicecandidate = (e) => {
-            nbCandidates++;
-            if (e.candidate) {
-                rawCandidates.push(e.candidate.candidate);
-            }
-            if (e.candidate && e.candidate.candidate.indexOf('srflx') !== -1) {
-                const cand = parseCandidate(e.candidate.candidate);
-                if (cand.relatedPort) {
-                    if (!candidates[cand.relatedPort]) {
-                        candidates[cand.relatedPort] = [];
-                    }
-                    candidates[cand.relatedPort].push(cand.port);
-                }
-            }
-            else if (!e.candidate) {
-                onEnded();
-            }
-        };
-        pc.createOffer().then(offer => pc.setLocalDescription(offer));
-    }),
-};

package/esm/checker/checks/wazo-websocket.js

@@ -1,38 +0,0 @@
-import WebSocketClient, { SOCKET_EVENTS, HEARTBEAT_ENGINE_VERSION } from '../../websocket-client';
-export default {
-    name: 'Event transport (WS)',
-    check: (server, session) => new Promise((resolve, reject) => {
-        const client = new WebSocketClient({
-            host: server,
-            token: session.token,
-            version: 2,
-        });
-        const handleError = (message) => {
-            client.close();
-            reject(new Error(message));
-        };
-        const handleSuccess = () => {
-            client.stopHeartbeat();
-            client.close();
-            resolve();
-        };
-        client.on(SOCKET_EVENTS.ON_ERROR, error => {
-            handleError(`Connection error : ${error}`);
-        });
-        client.on(SOCKET_EVENTS.ON_OPEN, () => {
-            if (session.hasEngineVersionGte(HEARTBEAT_ENGINE_VERSION)) {
-                client.setOnHeartbeatTimeout(() => {
-                    handleError('No response to heartbeat');
-                });
-                client.setOnHeartbeatCallback(() => {
-                    handleSuccess();
-                });
-                client.startHeartbeat();
-            }
-            else {
-                handleSuccess();
-            }
-        });
-        client.connect();
-    }),
-};

package/esm/checker/checks/webrtc-transport.js

@@ -1,35 +0,0 @@
-import WebRTCClient from '../../web-rtc-client';
-export default {
-    name: 'WebRTC Transport (WS) ~30s',
-    check: (server, session) => new Promise((resolve, reject) => {
-        const [host, port = 443] = server.split(':');
-        const client = new WebRTCClient({
-            host,
-            port,
-            media: {
-                audio: true,
-            },
-        }, session);
-        const handleError = (message) => {
-            client.close();
-            reject(new Error(message));
-        };
-        const handleSuccess = async () => {
-            client.stopHeartbeat();
-            await client.close();
-            resolve();
-        };
-        client.on(client.TRANSPORT_ERROR, error => {
-            handleError(`Transport error : ${error}`);
-        });
-        client.on(client.REGISTERED, () => {
-            client.setOnHeartbeatTimeout(() => {
-                handleError('No response to heartbeat');
-            });
-            client.setOnHeartbeatCallback(() => {
-                handleSuccess();
-            });
-            client.startHeartbeat();
-        });
-    }),
-};