@wazo/sdk 0.39.0-beta.8 → 0.39.0

package/src/__tests__/api-client.test.ts

@@ -1,9 +1,13 @@
+import { AbortController } from 'node-abort-controller';
 import { Base64 } from 'js-base64';
+
 import WazoApiClient from '../api-client';
 import ServerError from '../domain/ServerError';
 import BadResponse from '../domain/BadResponse';
 import Session from '../domain/Session';
 
+const controller = new AbortController();
+
 const mockedResponse = {
   data: {
     token: 1,
@@ -75,7 +79,7 @@ const server = 'localhost';
 const authVersion = '0.1';
 const username = 'wazo';
 const password = 'zowa';
-jest.mock('node-fetch/lib/index', () => {});
+jest.mock('node-fetch/src/index', () => {});
 const token = '1234';
 
 const client = new WazoApiClient({
@@ -112,6 +116,7 @@ describe('With correct API results', () => {
       expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token`, {
         method: 'post',
         body: JSON.stringify(data),
+        signal: controller.signal,
         headers,
         agent: null,
       });
@@ -126,6 +131,7 @@ describe('With correct API results', () => {
       expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token/${oldToken}`, {
         method: 'delete',
         body: null,
+        signal: controller.signal,
         headers: {},
         agent: null,
       });
@@ -148,6 +154,7 @@ describe('With unAuthorized API results', () => {
       expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token/${tokenToCheck}`, {
         method: 'head',
         body: null,
+        signal: controller.signal,
         headers: {},
         agent: null,
       });
@@ -179,6 +186,7 @@ describe('With not found API results', () => {
       expect(global.fetch).toBeCalledWith(`https://${server}/api/calld/1.0/users/me/voicemails`, {
         method: 'get',
         body: null,
+        signal: controller.signal,
         headers: {
           'X-Auth-Token': token,
           'Content-Type': 'application/json',

package/src/__tests__/web-rtc-client.test.ts

@@ -1,6 +1,18 @@
 import WebRTCClient from '../web-rtc-client';
 
 jest.mock('sip.js/lib/platform/web/transport');
+jest.mock('sip.js/lib/api/user-agent', () => ({
+  start: () => {},
+  UserAgent: class UserAgent {
+    // @ts-ignore
+    static makeURI = () => {};
+
+    // @ts-ignore
+    start = () => {};
+
+    transport = {};
+  },
+}));
 
 // @ts-expect-error
 const client = new WebRTCClient({});

package/src/api/chatd.ts

@@ -38,7 +38,7 @@ export interface ChatD {
   getState: (contactUuid: UUID) => Promise<string>;
   getContactStatusInfo: (contactUuid: UUID) => Promise<PresenceResponse>;
   getLineState: (contactUuid: UUID) => Promise<string>;
-  getMultipleLineState: (contactUuids: Array<UUID> | null | undefined) => Promise<string>;
+  getMultipleLineState: (contactUuids: Array<UUID> | null | undefined) => Promise<Array<PresenceResponse>>;
   getUserRooms: () => Promise<Array<ChatRoom>>;
   createRoom: (name: string, users: Array<ChatUser>) => Promise<ChatRoom>;
   getRoomMessages: (roomUuid: string, params?: GetMessagesOptions) => Promise<Array<ChatMessage>>;
@@ -46,6 +46,9 @@ export interface ChatD {
   getMessages: (options: GetMessagesOptions) => Promise<ChatMessage>;
 }
 
+// split contact status retrieval to avoid `414 Request-URI Too Large`.
+const MAX_PRESENCE_FETCHED = 30;
+
 export default ((client: ApiRequester, baseUrl: string): ChatD => ({
   updateState: (contactUuid: UUID, state: string): Promise<boolean> => client.put(`${baseUrl}/users/${contactUuid}/presences`, {
     state,
@@ -60,11 +63,26 @@ export default ((client: ApiRequester, baseUrl: string): ChatD => ({
   getState: async (contactUuid: UUID): Promise<string> => client.get(`${baseUrl}/users/${contactUuid}/presences`).then((response: PresenceResponse) => response.state),
   getContactStatusInfo: async (contactUuid: UUID): Promise<PresenceResponse> => client.get(`${baseUrl}/users/${contactUuid}/presences`).then((response: PresenceResponse) => response),
   getLineState: async (contactUuid: UUID): Promise<string> => client.get(`${baseUrl}/users/${contactUuid}/presences`).then((response: PresenceResponse) => Profile.getLinesState(response.lines)),
-  getMultipleLineState: async (contactUuids: Array<UUID> | null | undefined): Promise<string> => {
+  async getMultipleLineState(contactUuids: Array<UUID> | null | undefined): Promise<Array<PresenceResponse>> {
     const body: any = {};
+    const uuids: Array<UUID> = contactUuids || [];
+
+    if (uuids.length > MAX_PRESENCE_FETCHED) {
+      const requests = uuids.reduce((acc, _, i) => {
+        if (i % MAX_PRESENCE_FETCHED === 0) {
+          // @ts-ignore
+          acc.push(this.getMultipleLineState(uuids.slice(i, i + MAX_PRESENCE_FETCHED)));
+        }
+        return acc;
+      }, []);
+
+      const splittedStatuses = await Promise.all(requests);
+
+      return splittedStatuses.flat();
+    }
 
-    if (contactUuids && contactUuids.length) {
-      body.user_uuid = contactUuids.join(',');
+    if (uuids.length) {
+      body.user_uuid = uuids.join(',');
     }
 
     return client.get(`${baseUrl}/users/presences`, body).then((response: PresenceListResponse) => response.items);

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]);
+  });
 });