@azure/msal-angular 3.0.0-beta.0 → 3.0.0

package/src/IMsalService.ts

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+  EndSessionRequest,
+  AuthorizationUrlRequest,
+  AuthenticationResult,
+  PopupRequest,
+  RedirectRequest,
+  SilentRequest,
+  Logger,
+} from '@azure/msal-browser';
+import { Observable } from 'rxjs';
+
+export interface IMsalService {
+  initialize(): Observable<void>;
+  acquireTokenPopup(request: PopupRequest): Observable<AuthenticationResult>;
+  acquireTokenRedirect(request: RedirectRequest): Observable<void>;
+  acquireTokenSilent(
+    silentRequest: SilentRequest
+  ): Observable<AuthenticationResult>;
+  handleRedirectObservable(): Observable<AuthenticationResult | null>;
+  loginPopup(request?: PopupRequest): Observable<AuthenticationResult>;
+  loginRedirect(request?: RedirectRequest): Observable<void>;
+  logout(logoutRequest?: EndSessionRequest): Observable<void>;
+  ssoSilent(request: AuthorizationUrlRequest): Observable<AuthenticationResult>;
+  getLogger(): Logger;
+  setLogger(logger: Logger): void;
+}

package/src/constants.ts

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { InjectionToken } from '@angular/core';
+
+export const MSAL_INSTANCE = new InjectionToken<string>('MSAL_INSTANCE');
+
+export const MSAL_GUARD_CONFIG = new InjectionToken<string>(
+  'MSAL_GUARD_CONFIG'
+);
+
+export const MSAL_INTERCEPTOR_CONFIG = new InjectionToken<string>(
+  'MSAL_INTERCEPTOR_CONFIG'
+);
+
+export const MSAL_BROADCAST_CONFIG = new InjectionToken<string>(
+  'MSAL_BROADCAST_CONFIG'
+);

package/src/msal.broadcast.config.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export type MsalBroadcastConfiguration = {
+  eventsToReplay: number;
+};

package/src/msal.broadcast.service.spec.ts

@@ -0,0 +1,456 @@
+import { TestBed } from '@angular/core/testing';
+import {
+  EventType,
+  InteractionStatus,
+  InteractionType,
+  PublicClientApplication,
+} from '@azure/msal-browser';
+import { Subscription } from 'rxjs';
+import { MsalModule, MSAL_BROADCAST_CONFIG } from './public-api';
+import { MsalBroadcastService } from './msal.broadcast.service';
+
+let broadcastService: MsalBroadcastService;
+let subscription: Subscription;
+
+const msalInstance = new PublicClientApplication({
+  auth: {
+    clientId: '6226576d-37e9-49eb-b201-ec1eeb0029b6',
+    redirectUri: 'http://localhost:4200',
+  },
+});
+
+function initializeMsal(providers: any[] = []) {
+  TestBed.resetTestingModule();
+
+  TestBed.configureTestingModule({
+    imports: [
+      MsalModule.forRoot(msalInstance, null, {
+        interactionType: InteractionType.Popup,
+        protectedResourceMap: new Map(),
+      }),
+    ],
+    providers: [MsalBroadcastService, ...providers],
+  });
+  broadcastService = TestBed.inject(MsalBroadcastService);
+}
+
+describe('MsalBroadcastService', () => {
+  beforeEach(() => {
+    initializeMsal();
+  });
+
+  afterEach(() => {
+    subscription.unsubscribe();
+  });
+
+  it('broadcasts event from PublicClientApplication', (done) => {
+    const sub = broadcastService.msalSubject$.subscribe((result) => {
+      expect(result.eventType).toEqual(EventType.LOGIN_START);
+      expect(result.interactionType).toEqual(InteractionType.Popup);
+      expect(result.payload).toEqual(null);
+      expect(result.error).toEqual(null);
+      expect(result.timestamp).toBeInstanceOf(Number);
+      sub.unsubscribe();
+    });
+
+    const expectedInProgress = [
+      InteractionStatus.Startup,
+      InteractionStatus.Login,
+    ];
+    let index = 0;
+
+    subscription = broadcastService.inProgress$.subscribe((result) => {
+      expect(result).toEqual(expectedInProgress[index]);
+      if (index === expectedInProgress.length - 1) {
+        done();
+      } else {
+        index++;
+      }
+    });
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.LOGIN_START, InteractionType.Popup);
+  });
+
+  it('broadcasts previous events if MsalBroadcastConfig set and eventsToReplay is greater than 0', (done) => {
+    initializeMsal([
+      {
+        provide: MSAL_BROADCAST_CONFIG,
+        useValue: {
+          eventsToReplay: 3,
+        },
+      },
+    ]);
+
+    const expectedMsalSubjectFirstSubscription = [
+      {
+        eventType: EventType.LOGIN_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+    ];
+    let firstIndex = 0;
+
+    subscription = broadcastService.msalSubject$.subscribe((result) => {
+      expect(result.eventType).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].eventType
+      );
+      expect(result.interactionType).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].interactionType
+      );
+      expect(result.payload).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].payload
+      );
+      expect(result.error).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].error
+      );
+      expect(result.timestamp).toBeInstanceOf(Number);
+      if (firstIndex === expectedMsalSubjectFirstSubscription.length - 1) {
+        return;
+      } else {
+        firstIndex++;
+      }
+    });
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.LOGIN_START, InteractionType.Redirect);
+
+    subscription.unsubscribe();
+
+    let index = 0;
+    const expectedMsalSubject = [
+      {
+        eventType: EventType.LOGIN_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+      {
+        eventType: EventType.HANDLE_REDIRECT_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+      {
+        eventType: EventType.HANDLE_REDIRECT_END,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+    ];
+
+    const newSubscription = broadcastService.msalSubject$.subscribe(
+      (result) => {
+        expect(result.eventType).toEqual(expectedMsalSubject[index].eventType);
+        expect(result.interactionType).toEqual(
+          expectedMsalSubject[index].interactionType
+        );
+        expect(result.payload).toEqual(expectedMsalSubject[index].payload);
+        expect(result.error).toEqual(expectedMsalSubject[index].error);
+        expect(result.timestamp).toBeInstanceOf(Number);
+        if (index === expectedMsalSubject.length - 1) {
+          done();
+        } else {
+          index++;
+        }
+      }
+    );
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
+
+    newSubscription.unsubscribe();
+  });
+
+  it('broadcasts the set number of past events if MsalBroadcastConfig and eventsToReplay is set', (done) => {
+    initializeMsal([
+      {
+        provide: MSAL_BROADCAST_CONFIG,
+        useValue: {
+          eventsToReplay: 1,
+        },
+      },
+    ]);
+
+    const expectedMsalSubjectFirstSubscription = [
+      {
+        eventType: EventType.INITIALIZE_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+      {
+        eventType: EventType.LOGIN_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+    ];
+    let firstIndex = 0;
+
+    subscription = broadcastService.msalSubject$.subscribe((result) => {
+      expect(result.eventType).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].eventType
+      );
+      expect(result.interactionType).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].interactionType
+      );
+      expect(result.payload).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].payload
+      );
+      expect(result.error).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].error
+      );
+      expect(result.timestamp).toBeInstanceOf(Number);
+      if (firstIndex === expectedMsalSubjectFirstSubscription.length - 1) {
+        return;
+      } else {
+        firstIndex++;
+      }
+    });
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.INITIALIZE_START, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.LOGIN_START, InteractionType.Redirect);
+
+    subscription.unsubscribe();
+
+    let index = 0;
+    const expectedMsalSubject = [
+      {
+        eventType: EventType.LOGIN_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+      {
+        eventType: EventType.HANDLE_REDIRECT_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+      {
+        eventType: EventType.HANDLE_REDIRECT_END,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+    ];
+
+    const newSubscription = broadcastService.msalSubject$.subscribe(
+      (result) => {
+        expect(result.eventType).toEqual(expectedMsalSubject[index].eventType);
+        expect(result.interactionType).toEqual(
+          expectedMsalSubject[index].interactionType
+        );
+        expect(result.payload).toEqual(expectedMsalSubject[index].payload);
+        expect(result.error).toEqual(expectedMsalSubject[index].error);
+        expect(result.timestamp).toBeInstanceOf(Number);
+        if (index === expectedMsalSubject.length - 1) {
+          done();
+        } else {
+          index++;
+        }
+      }
+    );
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
+
+    newSubscription.unsubscribe();
+  });
+
+  it('does not broadcasts previous events if MsalBroadcastConfig is not set', (done) => {
+    const expectedMsalSubjectFirstSubscription = [
+      {
+        eventType: EventType.LOGIN_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+    ];
+    let firstIndex = 0;
+
+    subscription = broadcastService.msalSubject$.subscribe((result) => {
+      expect(result.eventType).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].eventType
+      );
+      expect(result.interactionType).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].interactionType
+      );
+      expect(result.payload).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].payload
+      );
+      expect(result.error).toEqual(
+        expectedMsalSubjectFirstSubscription[firstIndex].error
+      );
+      expect(result.timestamp).toBeInstanceOf(Number);
+      if (firstIndex === expectedMsalSubjectFirstSubscription.length - 1) {
+        return;
+      } else {
+        firstIndex++;
+      }
+    });
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.LOGIN_START, InteractionType.Redirect);
+
+    subscription.unsubscribe();
+
+    let index = 0;
+    const expectedMsalSubject = [
+      {
+        eventType: EventType.HANDLE_REDIRECT_START,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+      {
+        eventType: EventType.HANDLE_REDIRECT_END,
+        interactionType: InteractionType.Redirect,
+        payload: null,
+        error: null,
+      },
+    ];
+
+    const newSubscription = broadcastService.msalSubject$.subscribe(
+      (result) => {
+        expect(result.eventType).toEqual(expectedMsalSubject[index].eventType);
+        expect(result.interactionType).toEqual(
+          expectedMsalSubject[index].interactionType
+        );
+        expect(result.payload).toEqual(expectedMsalSubject[index].payload);
+        expect(result.error).toEqual(expectedMsalSubject[index].error);
+        expect(result.timestamp).toBeInstanceOf(Number);
+        if (index === expectedMsalSubject.length - 1) {
+          done();
+        } else {
+          index++;
+        }
+      }
+    );
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
+
+    newSubscription.unsubscribe();
+  });
+
+  it('LOGIN_SUCCESS event does not set inProgress to None if handleRedirect is still in progress', (done) => {
+    const expectedInProgress = [
+      InteractionStatus.Startup,
+      InteractionStatus.HandleRedirect,
+    ];
+    let index = 0;
+
+    subscription = broadcastService.inProgress$.subscribe((result) => {
+      expect(result).toEqual(expectedInProgress[index]);
+      if (index === expectedInProgress.length - 1) {
+        done();
+      } else {
+        index++;
+      }
+    });
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Redirect);
+  });
+
+  it('HANDLE_REDIRECT_END event sets inProgress to None if handleRedirect is in progress', (done) => {
+    const expectedInProgress = [
+      InteractionStatus.Startup,
+      InteractionStatus.HandleRedirect,
+      InteractionStatus.None,
+    ];
+    let index = 0;
+
+    subscription = broadcastService.inProgress$.subscribe((result) => {
+      expect(result).toEqual(expectedInProgress[index]);
+      if (index === expectedInProgress.length - 1) {
+        done();
+      } else {
+        index++;
+      }
+    });
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
+  });
+
+  it('HANDLE_REDIRECT_END event does not set inProgress to None if login is in progress', (done) => {
+    const expectedInProgress = [
+      InteractionStatus.Startup,
+      InteractionStatus.HandleRedirect,
+      InteractionStatus.Login,
+    ];
+    let index = 0;
+
+    subscription = broadcastService.inProgress$.subscribe((result) => {
+      expect(result).toEqual(expectedInProgress[index]);
+      if (index === expectedInProgress.length - 1) {
+        done();
+      } else {
+        index++;
+      }
+    });
+
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.LOGIN_START, InteractionType.Redirect);
+    // @ts-ignore
+    msalInstance.controller
+      .getEventHandler()
+      .emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
+  });
+});

package/src/msal.broadcast.service.ts

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Inject, Injectable, Optional } from '@angular/core';
+import {
+  EventMessage,
+  EventMessageUtils,
+  IPublicClientApplication,
+  InteractionStatus,
+} from '@azure/msal-browser';
+import { BehaviorSubject, Observable, ReplaySubject, Subject } from 'rxjs';
+import { MsalService } from './msal.service';
+import { MsalBroadcastConfiguration } from './msal.broadcast.config';
+import { MSAL_BROADCAST_CONFIG, MSAL_INSTANCE } from './constants';
+
+@Injectable()
+export class MsalBroadcastService {
+  private _msalSubject: Subject<EventMessage>;
+  public msalSubject$: Observable<EventMessage>;
+  private _inProgress: BehaviorSubject<InteractionStatus>;
+  public inProgress$: Observable<InteractionStatus>;
+
+  constructor(
+    @Inject(MSAL_INSTANCE) private msalInstance: IPublicClientApplication,
+    private authService: MsalService,
+    @Optional()
+    @Inject(MSAL_BROADCAST_CONFIG)
+    private msalBroadcastConfig?: MsalBroadcastConfiguration
+  ) {
+    // Make _msalSubject a ReplaySubject if configured to replay past events
+    if (
+      this.msalBroadcastConfig &&
+      this.msalBroadcastConfig.eventsToReplay > 0
+    ) {
+      this.authService
+        .getLogger()
+        .verbose(
+          `BroadcastService - eventsToReplay set on BroadcastConfig, replaying the last ${this.msalBroadcastConfig.eventsToReplay} events`
+        );
+      this._msalSubject = new ReplaySubject<EventMessage>(
+        this.msalBroadcastConfig.eventsToReplay
+      );
+    } else {
+      // Defaults to _msalSubject being a Subject
+      this._msalSubject = new Subject<EventMessage>();
+    }
+
+    this.msalSubject$ = this._msalSubject.asObservable();
+
+    // InProgress as BehaviorSubject so most recent inProgress state will be available upon subscription
+    this._inProgress = new BehaviorSubject<InteractionStatus>(
+      InteractionStatus.Startup
+    );
+    this.inProgress$ = this._inProgress.asObservable();
+
+    this.msalInstance.addEventCallback((message: EventMessage) => {
+      this._msalSubject.next(message);
+      const status = EventMessageUtils.getInteractionStatusFromEvent(
+        message,
+        this._inProgress.value
+      );
+      if (status !== null) {
+        this.authService
+          .getLogger()
+          .verbose(
+            `BroadcastService - ${message.eventType} results in setting inProgress from ${this._inProgress.value} to ${status}`
+          );
+        this._inProgress.next(status);
+      }
+    });
+  }
+}

package/src/msal.guard.config.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { RouterStateSnapshot } from '@angular/router';
+import {
+  PopupRequest,
+  RedirectRequest,
+  InteractionType,
+} from '@azure/msal-browser';
+import { MsalService } from './msal.service';
+
+export declare type MsalGuardAuthRequest =
+  | Partial<PopupRequest>
+  | Partial<Omit<RedirectRequest, 'redirectStartPage'>>;
+
+export type MsalGuardConfiguration = {
+  interactionType: InteractionType.Popup | InteractionType.Redirect;
+  authRequest?:
+    | MsalGuardAuthRequest
+    | ((
+        authService: MsalService,
+        state: RouterStateSnapshot
+      ) => MsalGuardAuthRequest);
+  loginFailedRoute?: string;
+};