@wazo/sdk 0.39.0-beta.9 → 0.39.0

package/src/api/dird.ts

@@ -5,6 +5,7 @@ import Contact from '../domain/Contact';
 import type { NewContact } from '../domain/Contact';
 import type { DirectorySource, DirectorySources } from '../domain/DirectorySource';
 import type { Sources } from '../index';
+import { ContactsResponse } from '../index';
 
 const getContactPayload = (contact: NewContact | Contact) => ({
   email: contact.email,
@@ -51,9 +52,9 @@ type ContactSearchQueryParams = {
   uuid?: string;
 } | null;
 export default ((client: ApiRequester, baseUrl: string): DirD => ({
-  search: (context: string, term: string): Promise<Array<Contact>> => client.get(`${baseUrl}/directories/lookup/${context}`, {
+  search: (context: string, term: string, offset = 0, limit: (number | null) = null): Promise<Array<Contact>> => client.get(`${baseUrl}/directories/lookup/${context}`, {
     term,
-  }).then(Contact.parseMany),
+  }).then((response: ContactsResponse) => Contact.parseMany(response, offset, limit)),
   listPersonalContacts: (queryParams: ContactSearchQueryParams = null): Promise<Array<Contact>> => client.get(`${baseUrl}/personal`, queryParams).then((response: any) => Contact.parseManyPersonal(response.items)),
   fetchPersonalContact: (contactUuid: string): Promise<Contact> => client.get(`${baseUrl}/personal/${contactUuid}`).then(Contact.parsePersonal),
   addContact: (contact: NewContact): Promise<Contact> => client.post(`${baseUrl}/personal`, getContactPayload(contact)).then(Contact.parsePersonal),

package/src/api-client.ts

@@ -125,12 +125,12 @@ export default class ApiClient {
     this.initializeEndpoints();
   }
 
-  async forceRefreshToken() {
+  async forceRefreshToken(): Promise<string | null> {
     logger.info('forcing refresh token, calling callback');
     return this.refreshTokenCallback();
   }
 
-  async refreshTokenCallback() {
+  async refreshTokenCallback(): Promise<string | null> {
     logger.info('refresh token callback called', {
       refreshToken: this.refreshToken,
       refreshBackend: this.refreshBackend,
@@ -167,6 +167,8 @@ export default class ApiClient {
         this.onRefreshTokenError(error);
       }
     }
+
+    return null;
   }
 
   setToken(token: string) {
@@ -181,6 +183,10 @@ export default class ApiClient {
     this.refreshToken = refreshToken;
   }
 
+  setRequestTimeout(requestTimeout: number) {
+    this.client.setRequestTimeout(requestTimeout);
+  }
+
   setClientId(clientId: string | null | undefined) {
     this.client.clientId = clientId;
   }

package/src/checker/checks/ice-ipv4.ts

@@ -16,7 +16,8 @@ export default {
   name: 'Non IP v4 ice',
   check: (server: string, session: any, externalAppConfig: Record<string, any>) => new Promise((resolve, reject) => {
     if (typeof MediaStream === 'undefined') {
-      return resolve('Skipped on node');
+      resolve('Skipped on node');
+      return;
     }
 
     const mobile = isMobile();

package/src/domain/Contact.ts

@@ -326,12 +326,13 @@ export default class Contact {
     return aLastName.localeCompare(bLastName);
   }
 
-  static parseMany(response: ContactsResponse): Array<Contact> {
-    if (!response || !response.results) {
+  static parseMany(response: ContactsResponse, offset = 0, limit: (number | null) = null): Array<Contact> {
+    if (!response || !response.results || limit === 0) {
       return [];
     }
 
-    return response.results.map(r => Contact.parse(r, response.column_types));
+    const results = limit !== null && limit > 0 ? response.results.slice(offset, limit) : offset > 0 ? response.results.slice(offset) : response.results;
+    return results.map(r => Contact.parse(r, response.column_types));
   }
 
   static manyGraphQlWithNumbersParser(numbers: string[]): (...args: Array<any>) => any {
@@ -444,13 +445,20 @@ export default class Contact {
       address = `${postalAddress.street} ${postalAddress.city} ${postalAddress.postCode} ${postalAddress.country}`;
     }
 
+    const firstName = plain.givenName || '';
+    const lastName = plain.familyName || '';
+    const companyName = plain.company || '';
+    const isCompanyAccount = !firstName && !lastName;
+    const name = isCompanyAccount ? companyName : `${firstName} ${lastName}`;
+
     return new Contact({
-      name: `${plain.givenName || ''} ${plain.familyName || ''}`,
+      name,
       number: plain.phoneNumbers.length ? plain.phoneNumbers[0].number : '',
-      numbers: plain.phoneNumbers.length ? [{
-        label: 'primary',
-        number: plain.phoneNumbers[0].number,
-      }] : [],
+      // Make numbers unique
+      numbers: [...new Map(plain.phoneNumbers.map(item => [item.number, item])).values()].map((item, idx) => ({
+        label: idx === 0 ? 'primary' : 'secondary',
+        number: item.number,
+      })),
       email: plain.emailAddresses.length ? plain.emailAddresses[0].email : '',
       emails: plain.emailAddresses.length ? [{
         label: 'primary',

package/src/domain/Phone/WebRTCPhone.ts

@@ -382,8 +382,6 @@ export default class WebRTCPhone extends Emitter implements Phone {
         delete this.callSessions[sipSessionId];
         this.eventEmitter.emit(ON_CALL_CANCELED, callSession, elsewhere);
       };
-    } else if (sipSession instanceof Invitation) {
-      console.warn('sipSession._onCancel not found, please update the wazo SDK accordingly');
     }
 
     sipSession.stateChange.addListener((newState: SessionState) => {
@@ -453,11 +451,6 @@ export default class WebRTCPhone extends Emitter implements Phone {
         return this.eventEmitter.emit(ON_AUDIO_STREAM, stream);
       }
 
-      // not sure this does anything
-      if (kind === 'video') {
-        event.track.enabled = false;
-      }
-
       return this.eventEmitter.emit(ON_VIDEO_STREAM, stream, event.track.id, event, sipSession);
     };
 
@@ -509,7 +502,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return screenShareStream;
   }
 
-  async stopScreenSharing(restoreLocalStream = true, callSession?: CallSession | null | undefined): Promise<OutgoingInviteRequest | void> {
+  async stopScreenSharing(restoreLocalStream = true, callSession?: CallSession | null | undefined): Promise<OutgoingInviteRequest | void | null> {
     if (!this.currentScreenShare) {
       return;
     }
@@ -517,11 +510,13 @@ export default class WebRTCPhone extends Emitter implements Phone {
     logger.info('WebRTC phone - stop screen sharing', {
       restoreLocalStream,
     });
-    let reinvited: OutgoingInviteRequest | void;
+    let reinvited: OutgoingInviteRequest | null | void = null;
 
     try {
       if (this.currentScreenShare.stream) {
-        this.currentScreenShare.stream.getTracks().forEach((track: MediaStreamTrack) => track.stop());
+        this.currentScreenShare.stream.getTracks()
+          .filter((track: MediaStreamTrack) => track.enabled)
+          .forEach((track: MediaStreamTrack) => track.stop());
       }
 
       if (restoreLocalStream) {
@@ -552,6 +547,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       screensharing: false,
     }) : null);
     this.currentScreenShare = null;
+
     return reinvited;
   }
 
@@ -1369,12 +1365,15 @@ export default class WebRTCPhone extends Emitter implements Phone {
     logger.info('WebRTC close');
 
     try {
-      await Promise.race([this.unregister(), new Promise((resolve, reject) => setTimeout(() => reject(new Error('Unregister, timed out')), 3000))]);
+      await Promise.race([
+        this.unregister(),
+        new Promise((resolve, reject) => setTimeout(() => reject(new Error('Unregister, timed out')), 3000)),
+      ]);
     } catch (e: any) {
       logger.error('WebRTC close, unregister error', e);
     }
 
-    this.client.close(force);
+    await this.client.close(force);
     this.unbind();
     this.incomingSessions = [];
     this.currentSipSession = undefined;

package/src/domain/Session.ts

@@ -72,6 +72,8 @@ type SessionArguments = {
 export default class Session {
   acl: string[];
 
+  contact?: Contact;
+
   token: string;
 
   refreshToken: string | null | undefined;
@@ -198,6 +200,32 @@ export default class Session {
     return this.profile && (this.profile.sipLines || []).find(sipLine => sipLine && !sipLine.isWebRtc());
   }
 
+  getContact(): Contact {
+    if (this.contact) {
+      return this.contact;
+    }
+
+    const { email, firstName, lastName, mobileNumber, state, status } = this.profile || {};
+    const number = this.primaryNumber() || '';
+    const numbers = [{ label: 'primary', number }];
+
+    if (mobileNumber) {
+      numbers.push({ label: 'mobile', number: mobileNumber });
+    }
+
+    return new Contact({
+      uuid: this.uuid || '',
+      email,
+      name: `${firstName} ${lastName}`,
+      number,
+      numbers,
+      state: state || '',
+      status,
+      backend: 'wazo',
+      source: 'default',
+    });
+  }
+
   primaryContext(): string {
     if (this.engineVersion) {
       if (this.hasEngineVersionGte(MINIMUM_WAZO_ENGINE_VERSION_FOR_DEFAULT_CONTEXT)) {

package/src/domain/__tests__/Contact.test.ts

@@ -1,5 +1,138 @@
 import Contact from '../Contact';
 
+const genericContactResponse = {
+  column_types: [
+    'name',
+    'number',
+    'callable',
+    'voicemail',
+    'favorite',
+    'email',
+    'personal',
+  ],
+  term: 'a',
+  column_headers: [
+    'Nom',
+    'Num\u00e9ro',
+    'Mobile',
+    'Bo\u00eete vocale',
+    'Favoris',
+    'E-mail',
+    'Personnel',
+  ],
+  results: [],
+};
+
+const contact1 = {
+  source: 'internal',
+  column_values: [
+    'Jonathan Lessard',
+    '8020',
+    '06800880',
+    null,
+    false,
+    'jonathan@example.com',
+    false,
+  ],
+  backend: 'wazo',
+  relations: {
+    user_id: 8,
+    xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa8',
+    agent_id: null,
+    endpoint_id: 8,
+    user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
+    source_entry_id: '8',
+  },
+};
+
+const contact2 = {
+  source: 'internal',
+  column_values: [
+    'John Doe',
+    '8021',
+    '06800881',
+    null,
+    false,
+    'john@example.com',
+    false,
+  ],
+  backend: 'wazo',
+  relations: {
+    user_id: 9,
+    xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa9',
+    agent_id: null,
+    endpoint_id: 9,
+    user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b55',
+    source_entry_id: '9',
+  },
+};
+
+const parsedContact1 = new Contact({
+  name: 'Jonathan Lessard',
+  number: '8020',
+  numbers: [
+    {
+      label: 'primary',
+      number: '8020',
+    },
+    {
+      label: 'secondary',
+      number: '06800880',
+    },
+  ],
+  favorited: false,
+  email: 'jonathan@example.com',
+  emails: [
+    {
+      label: 'primary',
+      email: 'jonathan@example.com',
+    },
+  ],
+  address: '',
+  entreprise: '',
+  birthday: '',
+  note: '',
+  endpointId: 8,
+  personal: false,
+  source: 'internal',
+  sourceId: '8',
+  uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
+  backend: 'wazo',
+});
+
+const parsedContact2 = new Contact({
+  name: 'John Doe',
+  number: '8021',
+  numbers: [
+    {
+      label: 'primary',
+      number: '8021',
+    },
+    {
+      label: 'secondary',
+      number: '06800881',
+    },
+  ],
+  favorited: false,
+  email: 'john@example.com',
+  emails: [
+    {
+      label: 'primary',
+      email: 'john@example.com',
+    },
+  ],
+  address: '',
+  entreprise: '',
+  birthday: '',
+  note: '',
+  endpointId: 9,
+  personal: false,
+  source: 'internal',
+  sourceId: '9',
+  uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b55',
+  backend: 'wazo',
+});
+
 describe('Contact domain', () => {
   it('is extern when given no uuid', () => {
     const boba = new Contact({});
@@ -132,10 +265,7 @@ describe('Contact domain', () => {
     const contact = new Contact({
       name: 'John Smith',
     });
-    const {
-      firstName,
-      lastName,
-    } = contact.separateName();
+    const { firstName, lastName } = contact.separateName();
     expect(firstName).toBe('John');
     expect(lastName).toBe('Smith');
   });
@@ -143,10 +273,7 @@ describe('Contact domain', () => {
     const contact = new Contact({
       name: 'John  Smith',
     });
-    const {
-      firstName,
-      lastName,
-    } = contact.separateName();
+    const { firstName, lastName } = contact.separateName();
     expect(firstName).toBe('John');
     expect(lastName).toBe('Smith');
   });
@@ -172,67 +299,99 @@ describe('Contact domain', () => {
   });
   it('can parse a plain contact to domain', () => {
     const response = {
-      column_types: ['name', 'number', 'callable', 'voicemail', 'favorite', 'email', 'personal'],
-      term: 'a',
-      column_headers: ['Nom', 'Num\u00e9ro', 'Mobile', 'Bo\u00eete vocale', 'Favoris', 'E-mail', 'Personnel'],
-      results: [{
-        source: 'internal',
-        column_values: ['Jonathan Lessard', '8020', '06800880', null, false, 'contact@nexapp.ca', false],
-        backend: 'wazo',
-        relations: {
-          user_id: 8,
-          xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa8',
-          agent_id: null,
-          endpoint_id: 8,
-          user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
-          source_entry_id: '8',
-        },
-      }],
+      ...genericContactResponse,
+      results: [contact1],
     };
     const contact = Contact.parse(response.results[0], response.column_types);
-    expect(contact).toEqual(new Contact({
-      name: 'Jonathan Lessard',
-      number: '8020',
-      numbers: [{
-        label: 'primary',
-        number: '8020',
-      }, {
-        label: 'secondary',
-        number: '06800880',
-      }],
-      favorited: false,
-      email: 'contact@nexapp.ca',
-      emails: [{
-        label: 'primary',
-        email: 'contact@nexapp.ca',
-      }],
-      address: '',
-      entreprise: '',
-      birthday: '',
-      note: '',
-      endpointId: 8,
-      personal: false,
-      source: 'internal',
-      sourceId: '8',
-      uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
-      backend: 'wazo',
-    }));
+    expect(contact).toEqual(parsedContact1);
   });
   it('should merge 2 contact', () => {
-    const contact = new Contact({
+    const noBirthdayContact = new Contact({
       uuid: 'uuid-12345',
       lastActivity: 'yesterday',
       // @ts-expect-error
       birthday: null,
     });
-    const contact2 = new Contact({
+    const noLastActivityContact = new Contact({
       uuid: 'uuid-12345',
       // @ts-expect-error
       lastActivity: null,
       birthday: 'tomorrow',
     });
-    const result = contact.merge(contact2);
+    const result = noBirthdayContact.merge(noLastActivityContact);
     expect(result.lastActivity).toBe('yesterday');
     expect(result.birthday).toBe('tomorrow');
   });
+  it('returns all contacts when parsing many contacts with no limit', () => {
+    const response = {
+      ...genericContactResponse,
+      results: [contact1, contact2],
+    };
+
+    const contacts = Contact.parseMany(response);
+    expect(contacts).toEqual([parsedContact1, parsedContact2]);
+  });
+  it('returns all contacts when parsing many contacts with a higher limit than number of results', () => {
+    const response = {
+      ...genericContactResponse,
+      results: [contact1, contact2],
+    };
+
+    const contacts = Contact.parseMany(response, 0, 1000);
+    expect(contacts).toEqual([parsedContact1, parsedContact2]);
+  });
+  it('returns limited contacts when parsing many contacts with a smaller limit than number of results', () => {
+    const response = {
+      ...genericContactResponse,
+      results: [contact1],
+    };
+
+    const contacts = Contact.parseMany(response, 0, 1);
+    expect(contacts).toEqual([parsedContact1]);
+  });
+  it('returns all contacts when parsing many contacts with same limit than number of results', () => {
+    const response = {
+      ...genericContactResponse,
+      results: [contact1, contact2],
+    };
+
+    const contacts = Contact.parseMany(response, 0, 2);
+    expect(contacts).toEqual([parsedContact1, parsedContact2]);
+  });
+  it('returns an empty array when parsing many contact with limit of 0', () => {
+    const response = {
+      ...genericContactResponse,
+      results: [contact1, contact2],
+    };
+
+    const contacts = Contact.parseMany(response, 0, 0);
+    expect(contacts).toEqual([]);
+  });
+  it('returns all contacts when parsing many contacts with a negative limit', () => {
+    const response = {
+      ...genericContactResponse,
+      results: [contact1, contact2],
+    };
+
+    const contacts = Contact.parseMany(response, 0, -1);
+    expect(contacts).toEqual([parsedContact1, parsedContact2]);
+  });
+  it('returns all contacts when parsing many contacts with a null limit', () => {
+    const response = {
+      ...genericContactResponse,
+      results: [contact1, contact2],
+    };
+
+    const contacts = Contact.parseMany(response, 0, null);
+    expect(contacts).toEqual([parsedContact1, parsedContact2]);
+  });
+  it('returns all contacts after the first one when parsing many contacts with an offset of 1', () => {
+    const response = {
+      ...genericContactResponse,
+      results: [contact1, contact2],
+    };
+
+    const contacts = Contact.parseMany(response, 1, null);
+    expect(contacts).toEqual([parsedContact2]);
+  });
 });

package/src/domain/types.ts

@@ -1,3 +1,7 @@
+import type { Session, UserAgentOptions as sipJsUserAgentOptions } from 'sip.js';
+import { SessionDescriptionHandlerFactoryOptions } from 'sip.js/lib/platform/web';
+import WazoSessionDescriptionHandler from '../lib/WazoSessionDescriptionHandler';
+
 // @TODO: stand-in for empty object types. Was `type Something = {};` in JS
 type TodoObject = object;
 
@@ -202,20 +206,6 @@ export type ListCallNodesResponse = {
 };
 export type GetTenantResponse = TodoObject;
 export type GetUserResponse = TodoObject;
-export type WebRtcConfig = {
-  id: number;
-  host: string;
-  line: {
-    id: number;
-    links: Array<Link>;
-  };
-  links: Array<Link>;
-  options: Array<Array<string>>;
-  secret: string;
-  tenant_uuid: string;
-  type: string;
-  username: string;
-};
 export type CTITransfer = {
   'flow': string;
   'id': string;
@@ -225,3 +215,41 @@ export type CTITransfer = {
   'status': string;
   'transferred_call': string;
 };
+export type UserAgentOptions = sipJsUserAgentOptions & {
+  peerConnectionOptions?: Record<string, any>,
+  sessionDescriptionHandlerFactory: (session: Session, options: SessionDescriptionHandlerFactoryOptions) => WazoSessionDescriptionHandler,
+};
+export type UserAgentConfigOverrides = Partial<UserAgentOptions & {
+  traceSip: any,
+}>;
+export type MediaConfig = {
+  audio: Record<string, any> | boolean;
+  video?: Record<string, any> | boolean;
+  localVideo?: Record<string, any> | boolean;
+};
+export type WebRtcConfig = {
+  displayName?: string;
+  host: string;
+  port?: number;
+  websocketSip?: string;
+  authorizationUser?: string;
+  password?: string;
+  uri?: string;
+  media?: MediaConfig;
+  iceCheckingTimeout?: number;
+  log?: Record<string, any>;
+  audioOutputDeviceId?: string;
+  audioOutputVolume?: number;
+  userAgentString?: string;
+  heartbeatDelay?: number;
+  heartbeatTimeout?: number;
+  maxHeartbeats?: number;
+  skipRegister?: boolean;
+  userUuid?: string,
+}; // @see https://github.com/onsip/SIP.js/blob/master/src/Web/Simple.js
+
+export type ConnectionOptions = WebRtcConfig & {
+  uaConfigOverrides: UserAgentConfigOverrides,
+  audioDeviceOutput: string,
+  audioDeviceRing: string
+};

package/src/lib/WazoSessionDescriptionHandler.ts

@@ -208,20 +208,24 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
       return;
     }
 
-    // Closing senders via getLocalStreams
+    // Closing senders via getLocalStreams, `getLocalStreams` is deprecated, we have to check if it exists.
     // @ts-ignore
-    this.peerConnection?.getLocalStreams().forEach(stream => {
-      stream.getTracks().forEach((track: MediaStreamTrack) => {
-        track.stop();
+    if (this.peerConnection?.getLocalStreams) {
+      // @ts-ignore
+      this.peerConnection?.getLocalStreams().forEach(stream => {
+        stream.getTracks()
+          .filter((track: MediaStreamTrack) => track.enabled)
+          .forEach((track: MediaStreamTrack) => track.stop());
       });
-    });
-    // Closing receivers via getRemoteStreams
-    // @ts-ignore
-    this.peerConnection?.getRemoteStreams().forEach(stream => {
-      stream.getTracks().forEach((track: MediaStreamTrack) => {
-        track.stop();
+
+      // Closing receivers via getRemoteStreams
+      // @ts-ignore
+      this.peerConnection?.getRemoteStreams().forEach(stream => {
+        stream.getTracks()
+          .filter((track: MediaStreamTrack) => track.enabled)
+          .forEach((track: MediaStreamTrack) => track.stop());
       });
-    });
+    }
 
     if (this._dataChannel) {
       this._dataChannel.close();

package/src/service/IssueReporter.ts

@@ -14,7 +14,7 @@ const ERROR = 'error';
 const CONSOLE_METHODS = [INFO, LOG, WARN, ERROR];
 const LOG_LEVELS = [TRACE, DEBUG, INFO, LOG, WARN, ERROR];
 const CATEGORY_PREFIX = 'logger-category=';
-const MAX_REMOTE_RETRY = 100;
+const MAX_REMOTE_RETRY = 10;
 
 const addLevelsTo = (instance: Record<string, any>, withMethods = false) => {
   instance.TRACE = TRACE;
@@ -350,6 +350,15 @@ class IssueReporter {
     }
   }
 
+  _computeRetryDelay(attempt: number, initial = 1000, maxWait = 50000) {
+    // min wait is initial(attempt = 0)
+    // later retries are randomly distributed between initial wait and exponential
+    const base = 1.5;
+    const wait = Math.min(initial * base ** attempt, maxWait);
+    const jitterWait = Math.max(initial, Math.random() * wait);
+    return jitterWait;
+  }
+
   _sendDebugToGrafana(payload: string | Record<string, any> | Record<string, any>[], retry = 0) {
     if (!this.remoteClientConfiguration || retry >= MAX_REMOTE_RETRY) {
       return;
@@ -376,6 +385,8 @@ class IssueReporter {
       // @ts-ignore
       e.skipSendToRemote = true;
       this.log('error', this._makeCategory('grafana'), 'Sending log to grafana, error', e);
+      // wait at least 1 second, at most 50 seconds
+      const wait = this._computeRetryDelay(retry, 1000, 50000);
       setTimeout(() => {
         if (Array.isArray(payload)) {
           payload = payload.map(message => this._writeRetryCount(message, retry + 1));
@@ -384,7 +395,7 @@ class IssueReporter {
         }
 
         this._sendDebugToGrafana(payload, retry + 1);
-      }, 5000 + retry * 1000);
+      }, wait);
     });
   }