@wazo/sdk 0.43.1 → 0.43.3

package/src/api/auth.ts

@@ -27,6 +27,7 @@ export interface AuthD {
   logIn(params: LoginParams): Promise<Session | null | undefined> ;
   logOut: (token: Token) => Promise<LogoutResponse>;
   samlLogIn: (samlSessionId: string) => Promise<Session | null | undefined>;
+  initiateIdpAuthentication(domain: string, redirectUrl: string): Promise<any>;
   refreshToken: (refreshToken: string, backend: string, expiration: number, isMobile?: boolean, tenantId?: string, domainName?: string) => Promise<Session | null | undefined>;
   deleteRefreshToken: (clientId: string) => Promise<boolean>;
   updatePassword: (userUuid: UUID, oldPassword: string, newPassword: string) => Promise<boolean>;
@@ -116,6 +117,19 @@ export default ((client: ApiRequester, baseUrl: string): AuthD => ({
 
     return client.post(`${baseUrl}/token`, body).then(Session.parse);
   },
+  initiateIdpAuthentication: async (domain: string, redirectUrl: string) => {
+    const body = {
+      domain,
+      redirect_url: redirectUrl,
+    };
+
+    const headers = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    };
+
+    return client.post(`${baseUrl}/saml/sso`, body, headers, (response: any) => response);
+  },
   refreshToken: (refreshToken: string, backend: string, expiration: number, isMobile?: boolean, tenantId?: string, domainName?: string): Promise<Session | null | undefined> => {
     const body: Record<string, any> = {
       backend: backend || DEFAULT_BACKEND_USER,

package/src/simple/Auth.ts

@@ -24,6 +24,8 @@ export class InvalidSubscription extends Error {}
 export class InvalidAuthorization extends Error {}
 export class NoTenantIdError extends Error {}
 export class NoDomainNameError extends Error {}
+export class NoSamlRouteError extends Error {}
+export class SamlConfigError extends Error {}
 
 const logger = IssueReporter.loggerFor('simple-auth');
 
@@ -165,6 +167,31 @@ export class Auth {
     return this._onAuthenticated(rawSession as Session);
   }
 
+  async initiateIdpAuthentication(domain: string, redirectUrl: string): Promise<{ location: string, saml_session_id: string } | undefined> {
+    let response;
+    try {
+      response = await getApiClient().auth.initiateIdpAuthentication(domain, redirectUrl);
+    } catch (e: any) {
+      logger.error('Error during IdP authentication initiation:', e.message);
+      return;
+    }
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new NoSamlRouteError('No route found for saml sso');
+      }
+
+      if (response.status === 500) {
+        throw new SamlConfigError('SAML/server configuration error');
+      }
+
+      const error = await response.json();
+      throw new Error(error.message || error.reason);
+    }
+
+    return response.json();
+  }
+
   async logInViaRefreshToken(refreshToken: string): Promise<Session | null> {
     const rawSession = await getApiClient().auth.refreshToken(refreshToken, '', this.expiration, this.mobile);
     return this._onAuthenticated(rawSession as Session);

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

@@ -120,4 +120,127 @@ describe('simple/Auth', () => {
       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 ok', async () => {
+      const initiateIdpAuthentication = jest.fn(() =>
+        Promise.resolve({
+          ok: true,
+          status: 303,
+          json: () => Promise.resolve(validResponse),
+        }));
+
+      (getApiClient as any).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(() =>
+        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 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,
+        }));
+
+      (getApiClient as any).mockImplementation(() => ({
+        auth: {
+          initiateIdpAuthentication,
+        },
+      }));
+
+      await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('SAML/server configuration error');
+    });
+  });
 });

package/src/simple/index.ts

@@ -1,6 +1,6 @@
 /* eslint-disable import/no-named-as-default */
 /* global window */
-import Auth, { InvalidSubscription, InvalidAuthorization, NoTenantIdError, NoDomainNameError } from './Auth';
+import Auth, { InvalidSubscription, InvalidAuthorization, NoTenantIdError, NoDomainNameError, NoSamlRouteError, SamlConfigError } from './Auth';
 import Phone from './Phone';
 import Websocket from './Websocket';
 import Room from './room/Room';
@@ -138,6 +138,8 @@ const Wazo = {
   SFUNotAvailableError,
   NoTenantIdError,
   NoDomainNameError,
+  NoSamlRouteError,
+  SamlConfigError,
 };
 
 if (typeof window !== 'undefined') {