@wazo/sdk 0.43.4 → 0.43.6

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

@@ -131,7 +131,6 @@ describe('With correct API results', () => {
         body: JSON.stringify({ saml_session_id: samlSessionId }),
         signal: expect.any(Object),
         headers: {
-          'X-Auth-Token': token,
           'Content-Type': 'application/json',
           Accept: 'application/json',
         },
@@ -140,6 +139,28 @@ describe('With correct API results', () => {
     });
   });
 
+  describe('samlLogIn mobile test', () => {
+    it('should retrieve user token', async () => {
+      Wazo.Auth.mobile = true;
+      const samlSessionId = 'a1b2C3d4';
+      const result = await client.auth.samlLogIn(samlSessionId);
+
+      expect(result).toBeInstanceOf(Session);
+      expect(result?.token).toBe(1);
+      expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token`, {
+        method: 'post',
+        body: JSON.stringify({ saml_session_id: samlSessionId }),
+        signal: expect.any(Object),
+        headers: {
+          'Content-Type': 'application/json',
+          'Wazo-Session-Type': 'mobile',
+          Accept: 'application/json',
+        },
+        agent: null,
+      });
+    });
+  });
+
   describe('logOut test', () => {
     it('should delete the specified token', async () => {
       const oldToken = 123;

package/src/api/auth.ts

@@ -116,7 +116,13 @@ export default ((client: ApiRequester, baseUrl: string): AuthD => ({
   },
 
   logOut: (token: Token): Promise<LogoutResponse> => client.delete(`${baseUrl}/token/${token}`, null, {}, ApiRequester.successResponseParser),
+
   samlLogIn: async (samlSessionId: string): Promise<Session | null | undefined> => {
+    const headers: Record<string, any> = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    };
+
     const body: SamlLoginBody = {
       saml_session_id: samlSessionId,
     };
@@ -126,8 +132,13 @@ export default ((client: ApiRequester, baseUrl: string): AuthD => ({
       body.client_id = client.clientId;
     }
 
-    return client.post(`${baseUrl}/token`, body).then(Session.parse);
+    if (Wazo.Auth.mobile) {
+      headers['Wazo-Session-Type'] = 'mobile';
+    }
+
+    return client.post(`${baseUrl}/token`, body, headers).then(Session.parse);
   },
+
   initiateIdpAuthentication: async (domain: string, redirectUrl: string) => {
     const body = {
       domain,
@@ -139,7 +150,7 @@ export default ((client: ApiRequester, baseUrl: string): AuthD => ({
       'Content-Type': 'application/json',
     };
 
-    return client.post(`${baseUrl}/saml/sso`, body, headers, (response: any) => response);
+    return client.post(`${baseUrl}/saml/sso`, body, headers);
   },
   refreshToken: (refreshToken: string, backend: string, expiration: number, isMobile?: boolean, tenantId?: string, domainName?: string): Promise<Session | null | undefined> => {
     const body: Record<string, any> = {

package/src/simple/Auth.ts

@@ -168,28 +168,21 @@ export class Auth {
   }
 
   async initiateIdpAuthentication(domain: string, redirectUrl: string): Promise<{ location: string, saml_session_id: string } | undefined> {
-    let response;
     try {
-      response = await getApiClient().auth.initiateIdpAuthentication(domain, redirectUrl);
+      return await getApiClient().auth.initiateIdpAuthentication(domain, redirectUrl);
     } catch (e: any) {
       logger.error('Error during IdP authentication initialization:', e.message);
-      throw e;
-    }
 
-    if (!response.ok) {
-      if (response.status === 404) {
+      if (e.status === 404) {
         throw new NoSamlRouteError('No route found for SAML SSO');
       }
 
-      if (response.status === 500) {
+      if (e.status === 500) {
         throw new SamlConfigError('SAML/server configuration error');
       }
 
-      const error = await response.json();
-      throw new Error(error.message || error.reason);
+      throw e;
     }
-
-    return response.json();
   }
 
   async logInViaRefreshToken(refreshToken: string): Promise<Session | null> {

package/src/simple/__tests__/Auth.test.ts

@@ -1,3 +1,5 @@
+import BadResponse from '../../domain/BadResponse';
+import ServerError from '../../domain/ServerError';
 import getApiClient, { setRefreshToken } from '../../service/getApiClient';
 import { Auth as AuthClass } from '../Auth';
 
@@ -124,13 +126,8 @@ describe('simple/Auth', () => {
   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 ok', async () => {
-      const initiateIdpAuthentication = jest.fn(() =>
-        Promise.resolve({
-          ok: true,
-          status: 303,
-          json: () => Promise.resolve(validResponse),
-        }));
+    it('should return a `location` and `saml_session_id` if the response is valid', async () => {
+      const initiateIdpAuthentication = jest.fn(() => validResponse);
 
       (getApiClient as any).mockImplementation(() => ({
         auth: {
@@ -141,12 +138,9 @@ describe('simple/Auth', () => {
       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(() =>
-        Promise.resolve({
-          ok: false,
-          status: 404,
-        }));
+      const initiateIdpAuthentication = jest.fn(() => { throw BadResponse.fromText('an error message', 404); });
 
       (getApiClient as any).mockImplementation(() => ({
         auth: {
@@ -159,80 +153,8 @@ describe('simple/Auth', () => {
       );
     });
 
-    it('should return an error `message` if the response is NOT ok', async () => {
-      const initiateIdpAuthentication = jest.fn(() =>
-        Promise.resolve({
-          ok: false,
-          json: () => Promise.resolve({ message: 'an error message', reason: 'an error reason' }),
-        }));
-
-      (getApiClient as any).mockImplementation(() => ({
-        auth: {
-          initiateIdpAuthentication,
-        },
-      }));
-
-      await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow(
-        'an error message',
-      );
-    });
-
-    it('should return an error `reason` if there is no `message` and the response is NOT ok', async () => {
-      const initiateIdpAuthentication = jest.fn(() =>
-        Promise.resolve({
-          ok: false,
-          json: () => Promise.resolve({ reason: 'an error reason' }),
-        }));
-
-      (getApiClient as any).mockImplementation(() => ({
-        auth: {
-          initiateIdpAuthentication,
-        },
-      }));
-
-      await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow(
-        'an error reason',
-      );
-    });
-
-    it('should return an error with a null message if there is no `message` and `reason`', async () => {
-      const initiateIdpAuthentication = jest.fn(() =>
-        Promise.resolve({
-          ok: false,
-          json: () => Promise.resolve({}),
-        }));
-
-      (getApiClient as any).mockImplementation(() => ({
-        auth: {
-          initiateIdpAuthentication,
-        },
-      }));
-
-      await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('');
-    });
-
-    it('should return a NoSAMLRouteError if the response is a 404', async () => {
-      const initiateIdpAuthentication = jest.fn(() =>
-        Promise.resolve({
-          ok: false,
-          status: 404,
-        }));
-
-      (getApiClient as any).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(() =>
-        Promise.resolve({
-          ok: false,
-          status: 500,
-        }));
+    it('should return a `SamlConfigError` if the response is a 500', async () => {
+      const initiateIdpAuthentication = jest.fn(() => { throw ServerError.fromText('an error message', 500); });
 
       (getApiClient as any).mockImplementation(() => ({
         auth: {

package/src/utils/__tests__/api-requester.test.ts

@@ -158,3 +158,23 @@ describe('With a refresh token', () => {
     });
   });
 });
+
+describe('base64Encode', () => {
+  it('should encode a string using base64', () => {
+    const input = 'Hello World!';
+    const expectedOutput = 'SGVsbG8gV29ybGQh';
+    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
+  });
+
+  it('should handle special characters', () => {
+    const input = 'éà$@€';
+    const expectedOutput = 'w6nDoCRA4oKs';
+    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
+  });
+
+  it('should handle empty string', () => {
+    const input = '';
+    const expectedOutput = '';
+    expect(ApiRequester.base64Encode(input)).toBe(expectedOutput);
+  });
+});

package/src/utils/api-requester.ts

@@ -64,7 +64,15 @@ export default class ApiRequester {
   }
 
   static base64Encode(str: string): string {
-    return typeof btoa !== 'undefined' ? btoa(str) : Base64.encode(str);
+    if (typeof btoa !== 'undefined') {
+      try {
+        return btoa(str);
+      } catch (error) {
+        // fall back to Base64.encode if btoa fails
+      }
+    }
+
+    return Base64.encode(str);
   }
 
   // @see https://github.com/facebook/flow/issues/183#issuecomment-358607052