@azure/msal-angular 4.0.11 → 4.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure/msal-angular",
-  "version": "4.0.11",
+  "version": "4.0.13",
   "author": {
     "name": "Microsoft",
     "email": "nugetaad@microsoft.com",
@@ -12,36 +12,66 @@
     "url": "https://github.com/AzureAD/microsoft-authentication-library-for-js.git"
   },
   "description": "Microsoft Authentication Library for Angular",
-  "typings": "index.d.ts",
+  "scripts": {
+    "ng": "ng",
+    "start": "ng serve",
+    "build": "ng build",
+    "build:prod": "ng build --configuration production",
+    "build:all": "npm run build:browser && npm run build",
+    "build:all:prod": "npm run build:browser && npm run build:prod",
+    "build:browser": "cd ../.. && npm run build --workspace=@azure/msal-common --workspace=@azure/msal-browser",
+    "build:pack": "npm run build && cd dist && npm pack",
+    "deploy": "npm run build:all:prod && npm publish ./dist --workspaces=false",
+    "test": "ng test",
+    "test:coverage": "npm test",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "npm run lint -- --fix",
+    "e2e": "ng e2e",
+    "prepack": "npm run build:all",
+    "prepublishOnly": "echo Use npm run deploy && exit 1",
+    "format:check": "prettier --ignore-path .gitignore --check src",
+    "format:fix": "prettier --ignore-path .gitignore --write src"
+  },
+  "typings": "./dist/azure-msal-angular.d.ts",
   "beachball": {
     "disallowedChangeTypes": [
       "major"
     ]
   },
+  "devDependencies": {
+    "@angular-devkit/build-angular": "^15.1.5",
+    "@angular/animations": "^15.1.4",
+    "@angular/cli": "^15.1.5",
+    "@angular/common": "^15.1.4",
+    "@angular/compiler": "^15.1.4",
+    "@angular/compiler-cli": "^15.1.4",
+    "@angular/core": "^15.1.4",
+    "@angular/forms": "^15.1.4",
+    "@angular/platform-browser": "^15.1.4",
+    "@angular/platform-browser-dynamic": "^15.1.4",
+    "@angular/router": "^15.1.4",
+    "@azure/msal-browser": "^4.13.2",
+    "@types/jasmine": "~3.6.0",
+    "@types/jasminewd2": "~2.0.3",
+    "@types/node": "^12.11.1",
+    "eslint-config-msal": "file:../../shared-configs/eslint-config-msal",
+    "jasmine-core": "~4.0.0",
+    "jasmine-spec-reporter": "~5.0.0",
+    "karma": "~6.3.2",
+    "karma-chrome-launcher": "~3.1.0",
+    "karma-coverage-istanbul-reporter": "~3.0.2",
+    "karma-jasmine": "~5.0.0",
+    "karma-jasmine-html-reporter": "^2.0.0",
+    "ng-packagr": "^15.1.2",
+    "prettier": "2.8.7",
+    "rxjs": "^7.8.1",
+    "ts-node": "~8.3.0",
+    "tslib": "^2.0.0",
+    "typescript": "~4.8.4",
+    "zone.js": "~0.11.8"
+  },
   "peerDependencies": {
-    "@azure/msal-browser": "^4.11.1",
+    "@azure/msal-browser": "^4.13.2",
     "rxjs": "^7.0.0"
-  },
-  "module": "fesm2015/azure-msal-angular.mjs",
-  "es2020": "fesm2020/azure-msal-angular.mjs",
-  "esm2020": "esm2020/azure-msal-angular.mjs",
-  "fesm2020": "fesm2020/azure-msal-angular.mjs",
-  "fesm2015": "fesm2015/azure-msal-angular.mjs",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "esm2020": "./esm2020/azure-msal-angular.mjs",
-      "es2020": "./fesm2020/azure-msal-angular.mjs",
-      "es2015": "./fesm2015/azure-msal-angular.mjs",
-      "node": "./fesm2015/azure-msal-angular.mjs",
-      "default": "./fesm2020/azure-msal-angular.mjs"
-    }
-  },
-  "sideEffects": false,
-  "dependencies": {
-    "tslib": "^2.3.0"
   }
-}
+}

package/src/IMsalService.ts

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+  EndSessionRequest,
+  AuthenticationResult,
+  PopupRequest,
+  RedirectRequest,
+  SilentRequest,
+  Logger,
+  SsoSilentRequest,
+} 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>;
+  // @deprecated: Use logoutRedirect or logoutPopup
+  logout(logoutRequest?: EndSessionRequest): Observable<void>;
+  logoutRedirect(logoutRequest?: EndSessionRequest): Observable<void>;
+  logoutPopup(logoutRequest?: EndSessionRequest): Observable<void>;
+  ssoSilent(request: SsoSilentRequest): 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,471 @@
+import { TestBed } from "@angular/core/testing";
+import {
+  EventHandler,
+  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: "b5c2e510-4a17-4feb-b219-e55aa5b74144",
+    redirectUri: "http://localhost:4200",
+  },
+});
+
+let eventHandler;
+const eventSpy = jasmine.createSpy("addEventCallback");
+msalInstance.addEventCallback = eventSpy;
+
+function initializeMsal(providers: any[] = []) {
+  TestBed.resetTestingModule();
+
+  eventHandler = new EventHandler();
+  eventSpy.and.callFake((callback, types) => {
+    return eventHandler.addEventCallback(callback, types);
+  });
+
+  TestBed.configureTestingModule({
+    imports: [
+      MsalModule.forRoot(msalInstance, null, {
+        interactionType: InteractionType.Popup,
+        protectedResourceMap: new Map(),
+      }),
+    ],
+    providers: [MsalBroadcastService, ...providers],
+    teardown: { destroyAfterEach: false },
+  });
+  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++;
+      }
+    });
+
+    eventHandler.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++;
+      }
+    });
+
+    eventHandler.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++;
+        }
+      }
+    );
+
+    eventHandler.emitEvent(
+      EventType.HANDLE_REDIRECT_START,
+      InteractionType.Redirect
+    );
+    eventHandler.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++;
+      }
+    });
+
+    eventHandler.emitEvent(
+      EventType.INITIALIZE_START,
+      InteractionType.Redirect
+    );
+    eventHandler.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++;
+        }
+      }
+    );
+
+    eventHandler.emitEvent(
+      EventType.HANDLE_REDIRECT_START,
+      InteractionType.Redirect
+    );
+    eventHandler.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++;
+      }
+    });
+
+    eventHandler.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++;
+        }
+      }
+    );
+
+    eventHandler.emitEvent(
+      EventType.HANDLE_REDIRECT_START,
+      InteractionType.Redirect
+    );
+    eventHandler.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++;
+      }
+    });
+
+    eventHandler.emitEvent(
+      EventType.HANDLE_REDIRECT_START,
+      InteractionType.Redirect
+    );
+    eventHandler.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++;
+      }
+    });
+
+    eventHandler.emitEvent(
+      EventType.HANDLE_REDIRECT_START,
+      InteractionType.Redirect
+    );
+    eventHandler.emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Redirect);
+    eventHandler.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++;
+      }
+    });
+
+    eventHandler.emitEvent(
+      EventType.HANDLE_REDIRECT_START,
+      InteractionType.Redirect
+    );
+    eventHandler.emitEvent(EventType.LOGIN_START, InteractionType.Redirect);
+    eventHandler.emitEvent(
+      EventType.HANDLE_REDIRECT_END,
+      InteractionType.Redirect
+    );
+  });
+
+  it("automatically sets inProgress to None when handleRedirectPromise returns without emitting an event", (done) => {
+    const expectedInProgress = [
+      InteractionStatus.Startup,
+      InteractionStatus.None,
+    ];
+    let index = 0;
+
+    subscription = broadcastService.inProgress$.subscribe((result) => {
+      expect(result).toEqual(expectedInProgress[index]);
+      if (index === expectedInProgress.length - 1) {
+        done();
+      } else if (expectedInProgress[index] === InteractionStatus.Startup) {
+        index++;
+        broadcastService.resetInProgressEvent();
+      } else {
+        index++;
+      }
+    });
+
+    eventHandler.emitEvent(
+      EventType.INITIALIZE_START,
+      InteractionType.Redirect
+    );
+  });
+});