@recursyve/nice-auth0-kit 13.0.0-beta.0

package/README.md

@@ -0,0 +1,83 @@
+# NiceAuth0Kit
+
+Nice Auth0 kit is a wrapper of the OAuth2 and MFA api for Auth0. We support the password, refresh_token and mfa grant types.
+
+## Installation
+
+```shell
+npm install --save @recursyve/nice-auth0-kit
+```
+
+## Usage example
+
+All the magic is done with the `NiceAuthenticationService`.
+
+### Password Grant
+
+```ts
+import { lastValueFrom } from "rxjs";
+
+@Injectable()
+export class LoginService {
+    constructor(private auth: NiceAuthenticationService) {
+    }
+
+    public async login(): Promise<void> {
+        const res = await lastValueFrom(
+            this.auth.passwordGrant("username", "password")
+        );
+    }
+}
+```
+
+#### Response
+
+```json
+{
+    "success": bool,
+    "mfaRequired": bool
+}
+```
+
+#### NoAuthenticatorException
+
+The `NoAuthenticatorException` is thrown when an MFA is required and the user doesn't have an authenticator setup
+
+### Validate OOB code
+
+```ts
+import { lastValueFrom } from "rxjs";
+
+@Injectable()
+export class LoginService {
+    constructor(private auth: NiceAuthenticationService) {
+    }
+
+    public async validateCode(): Promise<void> {
+        const res = await lastValueFrom(
+            this.auth.validateOobCode("123456")
+        );
+    }
+}
+```
+
+### Add MFA Authenticator
+
+```ts
+import { lastValueFrom } from "rxjs";
+
+@Injectable()
+export class LoginService {
+    constructor(private auth: NiceAuthenticationService) {
+    }
+
+    public async addAuthenticator(): Promise<void> {
+        const res = await lastValueFrom(
+            this.auth.addMfaAuthenticator({
+                type: "sms",
+                phoneNumber: "1111111111"
+            })
+        );
+    }
+}
+```

package/esm2020/lib/api/auth0.api.mjs

@@ -0,0 +1,13 @@
+export class Auth0Api {
+    constructor(domain, path) {
+        this.domain = domain;
+        this.path = path;
+    }
+    url(route = "") {
+        if (route === "" && this.path === "") {
+            return this.domain;
+        }
+        return `${this.domain}/${this.path}/${route}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aDAuYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmljZS1hdXRoMC1raXQvc3JjL2xpYi9hcGkvYXV0aDAuYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxRQUFRO0lBQ2pCLFlBQW9CLE1BQWMsRUFBVSxJQUFZO1FBQXBDLFdBQU0sR0FBTixNQUFNLENBQVE7UUFBVSxTQUFJLEdBQUosSUFBSSxDQUFRO0lBQUcsQ0FBQztJQUVsRCxHQUFHLENBQUMsS0FBSyxHQUFHLEVBQUU7UUFDcEIsSUFBSSxLQUFLLEtBQUssRUFBRSxJQUFJLElBQUksQ0FBQyxJQUFJLEtBQUssRUFBRSxFQUFFO1lBQ2xDLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztTQUN0QjtRQUNELE9BQU8sR0FBRyxJQUFJLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxJQUFJLElBQUksS0FBSyxFQUFFLENBQUM7SUFDbEQsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIEF1dGgwQXBpIHtcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIGRvbWFpbjogc3RyaW5nLCBwcml2YXRlIHBhdGg6IHN0cmluZykge31cblxuICAgIHByb3RlY3RlZCB1cmwocm91dGUgPSBcIlwiKTogc3RyaW5nIHtcbiAgICAgICAgaWYgKHJvdXRlID09PSBcIlwiICYmIHRoaXMucGF0aCA9PT0gXCJcIikge1xuICAgICAgICAgICAgcmV0dXJuIHRoaXMuZG9tYWluO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBgJHt0aGlzLmRvbWFpbn0vJHt0aGlzLnBhdGh9LyR7cm91dGV9YDtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/api/exceptions/base.exception.mjs

@@ -0,0 +1,6 @@
+export class Auth0BaseException {
+    constructor(value) {
+        Object.assign(this, value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5leGNlcHRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uaWNlLWF1dGgwLWtpdC9zcmMvbGliL2FwaS9leGNlcHRpb25zL2Jhc2UuZXhjZXB0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxrQkFBa0I7SUFJM0IsWUFBWSxLQUF5QjtRQUNqQyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztJQUMvQixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgQXV0aDBCYXNlRXhjZXB0aW9uIHtcbiAgICBwdWJsaWMgZXJyb3I6IHN0cmluZztcbiAgICBwdWJsaWMgZXJyb3JEZXNjcmlwdGlvbjogc3RyaW5nO1xuXG4gICAgY29uc3RydWN0b3IodmFsdWU6IEF1dGgwQmFzZUV4Y2VwdGlvbikge1xuICAgICAgICBPYmplY3QuYXNzaWduKHRoaXMsIHZhbHVlKTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/api/interceptors/auth.interceptor.mjs

@@ -0,0 +1,35 @@
+import { Inject, Injectable } from "@angular/core";
+import { mergeMap } from "rxjs";
+import { NICE_AUTH0_OPTIONS } from "../../nice-auth0-kit.constant";
+import { NiceAuthenticationService } from "../../providers/authentication.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../../providers/authentication.service";
+export class NiceAuthInterceptor {
+    constructor(options, authService) {
+        this.options = options;
+        this.authService = authService;
+    }
+    intercept(req, next) {
+        if (req.url.startsWith(`${this.options.domain}/oauth`)) {
+            return next.handle(req);
+        }
+        return this.authService.getAccessToken().pipe(mergeMap(token => {
+            if (!token) {
+                return next.handle(req);
+            }
+            const authReq = req.clone({
+                headers: req.headers.set("Authorization", `Bearer ${token}`)
+            });
+            return next.handle(authReq);
+        }));
+    }
+}
+NiceAuthInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuthInterceptor, deps: [{ token: NICE_AUTH0_OPTIONS }, { token: i1.NiceAuthenticationService }], target: i0.ɵɵFactoryTarget.Injectable });
+NiceAuthInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuthInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuthInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NICE_AUTH0_OPTIONS]
+                }] }, { type: i1.NiceAuthenticationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/api/mfa/exceptions/association-required.exception.mjs

@@ -0,0 +1,4 @@
+import { Auth0BaseException } from "../../exceptions/base.exception";
+export class Auth0AssociationRequiredException extends Auth0BaseException {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzb2NpYXRpb24tcmVxdWlyZWQuZXhjZXB0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmljZS1hdXRoMC1raXQvc3JjL2xpYi9hcGkvbWZhL2V4Y2VwdGlvbnMvYXNzb2NpYXRpb24tcmVxdWlyZWQuZXhjZXB0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRXJFLE1BQU0sT0FBTyxpQ0FBa0MsU0FBUSxrQkFBa0I7Q0FBRyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEF1dGgwQmFzZUV4Y2VwdGlvbiB9IGZyb20gXCIuLi8uLi9leGNlcHRpb25zL2Jhc2UuZXhjZXB0aW9uXCI7XG5cbmV4cG9ydCBjbGFzcyBBdXRoMEFzc29jaWF0aW9uUmVxdWlyZWRFeGNlcHRpb24gZXh0ZW5kcyBBdXRoMEJhc2VFeGNlcHRpb24ge31cbiJdfQ==

package/esm2020/lib/api/mfa/exceptions/mfa.exception.mjs

@@ -0,0 +1,5 @@
+export var MfaExceptions;
+(function (MfaExceptions) {
+    MfaExceptions["AssociationRequired"] = "association_required";
+})(MfaExceptions || (MfaExceptions = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWZhLmV4Y2VwdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25pY2UtYXV0aDAta2l0L3NyYy9saWIvYXBpL21mYS9leGNlcHRpb25zL21mYS5leGNlcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksYUFFWDtBQUZELFdBQVksYUFBYTtJQUNyQiw2REFBNEMsQ0FBQTtBQUNoRCxDQUFDLEVBRlcsYUFBYSxLQUFiLGFBQWEsUUFFeEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBNZmFFeGNlcHRpb25zIHtcbiAgICBBc3NvY2lhdGlvblJlcXVpcmVkID0gXCJhc3NvY2lhdGlvbl9yZXF1aXJlZFwiXG59XG4iXX0=

package/esm2020/lib/api/mfa/mfa.api.mjs

@@ -0,0 +1,55 @@
+import { HttpClient, HttpErrorResponse } from "@angular/common/http";
+import { Inject, Injectable } from "@angular/core";
+import { throwError } from "rxjs";
+import { catchError } from "rxjs/operators";
+import { NICE_AUTH0_OPTIONS } from "../../nice-auth0-kit.constant";
+import { Auth0Api } from "../auth0.api";
+import { Auth0AssociationRequiredException } from "./exceptions/association-required.exception";
+import { MfaExceptions } from "./exceptions/mfa.exception";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class Auth0MfaApi extends Auth0Api {
+    constructor(options, http) {
+        super(options.domain, "mfa");
+        this.options = options;
+        this.http = http;
+    }
+    challenge(req) {
+        return this.http.post(this.url("challenge"), {
+            client_id: this.options.clientId,
+            client_secret: this.options.clientSecret,
+            challenge_type: req.type,
+            mfa_token: req.mfaToken
+        }).pipe(catchError((e) => {
+            if (e instanceof HttpErrorResponse) {
+                const error = e.error;
+                if (error.error === MfaExceptions.AssociationRequired) {
+                    throwError(() => new Auth0AssociationRequiredException({
+                        error: error.error,
+                        errorDescription: error.error_description
+                    }));
+                }
+            }
+            return throwError(() => e);
+        }));
+    }
+    associateOobAuthenticator(req) {
+        return this.http.post(this.url("associate"), {
+            client_id: this.options.clientId,
+            client_secret: this.options.clientSecret,
+            authenticator_types: ["oob"],
+            oob_channels: req.channels,
+            phone_number: req.phoneNumber,
+            email: req.email
+        });
+    }
+}
+Auth0MfaApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Auth0MfaApi, deps: [{ token: NICE_AUTH0_OPTIONS }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+Auth0MfaApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Auth0MfaApi });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Auth0MfaApi, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NICE_AUTH0_OPTIONS]
+                }] }, { type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/api/mfa/model/mfa-request.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWZhLXJlcXVlc3QubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uaWNlLWF1dGgwLWtpdC9zcmMvbGliL2FwaS9tZmEvbW9kZWwvbWZhLXJlcXVlc3QubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQXV0aDBNZmFDaGFsbGVuZ2VSZXF1ZXN0IHtcbiAgICB0eXBlOiBzdHJpbmc7XG4gICAgbWZhVG9rZW46IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBBdXRoME1mYUFkZE9vYkF1dGhlbnRpY2F0b3JSZXF1ZXN0IHtcbiAgICBjaGFubmVsczogc3RyaW5nW107XG4gICAgcGhvbmVOdW1iZXI/OiBzdHJpbmc7XG4gICAgZW1haWw/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2020/lib/api/mfa/model/mfa-response.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWZhLXJlc3BvbnNlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmljZS1hdXRoMC1raXQvc3JjL2xpYi9hcGkvbWZhL21vZGVsL21mYS1yZXNwb25zZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBBdXRoMENoYWxsZW5nZVJlc3BvbnNlIHtcbiAgICBhdXRoZW50aWNhdG9yX3R5cGU6IHN0cmluZztcbiAgICBiaW5kaW5nX21ldGhvZDogc3RyaW5nO1xuICAgIG9vYl9jaGFubmVsOiBzdHJpbmc7XG4gICAgb29iX2NvZGU6IHN0cmluZztcbn1cbiJdfQ==

package/esm2020/lib/api/nice-auth0.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from "@angular/core";
+import { Auth0MfaApi } from "./mfa/mfa.api";
+import { Auth0TokenApi } from "./token/token.api";
+import * as i0 from "@angular/core";
+import * as i1 from "./mfa/mfa.api";
+import * as i2 from "./token/token.api";
+export class NiceAuth0Service {
+    constructor(mfa, token) {
+        this.mfa = mfa;
+        this.token = token;
+    }
+}
+NiceAuth0Service.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuth0Service, deps: [{ token: i1.Auth0MfaApi }, { token: i2.Auth0TokenApi }], target: i0.ɵɵFactoryTarget.Injectable });
+NiceAuth0Service.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuth0Service, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuth0Service, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Auth0MfaApi }, { type: i2.Auth0TokenApi }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmljZS1hdXRoMC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmljZS1hdXRoMC1raXQvc3JjL2xpYi9hcGkvbmljZS1hdXRoMC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUM1QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7Ozs7QUFLbEQsTUFBTSxPQUFPLGdCQUFnQjtJQUN6QixZQUFtQixHQUFnQixFQUFTLEtBQW9CO1FBQTdDLFFBQUcsR0FBSCxHQUFHLENBQWE7UUFBUyxVQUFLLEdBQUwsS0FBSyxDQUFlO0lBQUcsQ0FBQzs7NkdBRDNELGdCQUFnQjtpSEFBaEIsZ0JBQWdCLGNBRmIsTUFBTTsyRkFFVCxnQkFBZ0I7a0JBSDVCLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBBdXRoME1mYUFwaSB9IGZyb20gXCIuL21mYS9tZmEuYXBpXCI7XG5pbXBvcnQgeyBBdXRoMFRva2VuQXBpIH0gZnJvbSBcIi4vdG9rZW4vdG9rZW4uYXBpXCI7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiBcInJvb3RcIlxufSlcbmV4cG9ydCBjbGFzcyBOaWNlQXV0aDBTZXJ2aWNlIHtcbiAgICBjb25zdHJ1Y3RvcihwdWJsaWMgbWZhOiBBdXRoME1mYUFwaSwgcHVibGljIHRva2VuOiBBdXRoMFRva2VuQXBpKSB7fVxufVxuIl19

package/esm2020/lib/api/token/exceptions/mfa-required.exception.mjs

@@ -0,0 +1,7 @@
+import { Auth0BaseException } from "../../exceptions/base.exception";
+export class Auth0MfaRequiredException extends Auth0BaseException {
+    constructor(value) {
+        super(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWZhLXJlcXVpcmVkLmV4Y2VwdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25pY2UtYXV0aDAta2l0L3NyYy9saWIvYXBpL3Rva2VuL2V4Y2VwdGlvbnMvbWZhLXJlcXVpcmVkLmV4Y2VwdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUVyRSxNQUFNLE9BQU8seUJBQTBCLFNBQVEsa0JBQWtCO0lBRzdELFlBQVksS0FBZ0M7UUFDeEMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2pCLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEF1dGgwQmFzZUV4Y2VwdGlvbiB9IGZyb20gXCIuLi8uLi9leGNlcHRpb25zL2Jhc2UuZXhjZXB0aW9uXCI7XG5cbmV4cG9ydCBjbGFzcyBBdXRoME1mYVJlcXVpcmVkRXhjZXB0aW9uIGV4dGVuZHMgQXV0aDBCYXNlRXhjZXB0aW9uIHtcbiAgICBwdWJsaWMgbWZhVG9rZW46IHN0cmluZztcblxuICAgIGNvbnN0cnVjdG9yKHZhbHVlOiBBdXRoME1mYVJlcXVpcmVkRXhjZXB0aW9uKSB7XG4gICAgICAgIHN1cGVyKHZhbHVlKTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/api/token/exceptions/token.exception.mjs

@@ -0,0 +1,5 @@
+export var TokenExceptions;
+(function (TokenExceptions) {
+    TokenExceptions["MfaRequired"] = "mfa_required";
+})(TokenExceptions || (TokenExceptions = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4uZXhjZXB0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmljZS1hdXRoMC1raXQvc3JjL2xpYi9hcGkvdG9rZW4vZXhjZXB0aW9ucy90b2tlbi5leGNlcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksZUFFWDtBQUZELFdBQVksZUFBZTtJQUN2QiwrQ0FBNEIsQ0FBQTtBQUNoQyxDQUFDLEVBRlcsZUFBZSxLQUFmLGVBQWUsUUFFMUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBUb2tlbkV4Y2VwdGlvbnMge1xuICAgIE1mYVJlcXVpcmVkID0gXCJtZmFfcmVxdWlyZWRcIlxufVxuIl19

package/esm2020/lib/api/token/models/token-response.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tcmVzcG9uc2UubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uaWNlLWF1dGgwLWtpdC9zcmMvbGliL2FwaS90b2tlbi9tb2RlbHMvdG9rZW4tcmVzcG9uc2UubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQXV0aDBUb2tlblJlc3BvbnNlIHtcbiAgICBpZF90b2tlbjogc3RyaW5nO1xuICAgIGFjY2Vzc190b2tlbjogc3RyaW5nO1xuICAgIHJlZnJlc2hfdG9rZW46IHN0cmluZztcbiAgICB0b2tlbl90eXBlOiBzdHJpbmc7XG4gICAgZXhwaXJlc19pbjogbnVtYmVyO1xufVxuIl19

package/esm2020/lib/api/token/token.api.mjs

@@ -0,0 +1,78 @@
+import { HttpClient, HttpErrorResponse } from "@angular/common/http";
+import { Inject, Injectable } from "@angular/core";
+import { throwError } from "rxjs";
+import { catchError } from "rxjs/operators";
+import { NICE_AUTH0_OPTIONS } from "../../nice-auth0-kit.constant";
+import { Auth0Api } from "../auth0.api";
+import { Auth0MfaRequiredException } from "./exceptions/mfa-required.exception";
+import { TokenExceptions } from "./exceptions/token.exception";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class Auth0TokenApi extends Auth0Api {
+    constructor(options, http) {
+        super(options.domain, "oauth");
+        this.options = options;
+        this.http = http;
+    }
+    authWithPassword(username, password) {
+        return this.http.post(this.url("token"), {
+            client_id: this.options.clientId,
+            client_secret: this.options.clientSecret,
+            audience: this.options.audience,
+            grant_type: "password",
+            scope: this.options?.scopes.join(" ") ?? "",
+            username,
+            password
+        }).pipe(catchError((e) => {
+            if (e instanceof HttpErrorResponse) {
+                const error = e.error;
+                if (error.error === TokenExceptions.MfaRequired) {
+                    throwError(() => new Auth0MfaRequiredException({
+                        error: error.error,
+                        errorDescription: error.error_description,
+                        mfaToken: error.mfa_token
+                    }));
+                }
+            }
+            return throwError(() => e);
+        }));
+    }
+    authWithOobCode(mfaToken, oobCode, bindingCode) {
+        return this.http.post(this.url("token"), {
+            client_id: this.options.clientId,
+            client_secret: this.options.clientSecret,
+            audience: this.options.audience,
+            grant_type: "http://auth0.com/oauth/grant-type/mfa-oob",
+            scope: this.options?.scopes.join(" ") ?? "",
+            mfa_token: mfaToken,
+            oob_code: oobCode,
+            binding_code: bindingCode
+        });
+    }
+    refreshToken(refreshToken) {
+        return this.http.post(this.url("token"), {
+            client_id: this.options.clientId,
+            client_secret: this.options.clientSecret,
+            audience: this.options.audience,
+            grant_type: "refresh_token",
+            scope: this.options?.scopes.join(" ") ?? "",
+            refresh_token: refreshToken
+        });
+    }
+    revokeRefreshToken(refreshToken) {
+        return this.http.post(this.url("revoke"), {
+            client_id: this.options.clientId,
+            client_secret: this.options.clientSecret,
+            token: refreshToken
+        });
+    }
+}
+Auth0TokenApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Auth0TokenApi, deps: [{ token: NICE_AUTH0_OPTIONS }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+Auth0TokenApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Auth0TokenApi });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Auth0TokenApi, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NICE_AUTH0_OPTIONS]
+                }] }, { type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.api.js","sourceRoot":"","sources":["../../../../../../projects/nice-auth0-kit/src/lib/api/token/token.api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAc,UAAU,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;;;AAI/D,MAAM,OAAO,aAAc,SAAQ,QAAQ;IACvC,YAAgD,OAAyB,EAAU,IAAgB;QAC/F,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QADa,YAAO,GAAP,OAAO,CAAkB;QAAU,SAAI,GAAJ,IAAI,CAAY;IAEnG,CAAC;IAEM,gBAAgB,CAAC,QAAgB,EAAE,QAAgB;QACtD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACjB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EACjB;YACI,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAChC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY;YACxC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAC/B,UAAU,EAAE,UAAU;YACtB,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;YAC3C,QAAQ;YACR,QAAQ;SACX,CACJ,CAAC,IAAI,CACF,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE;YACb,IAAI,CAAC,YAAY,iBAAiB,EAAE;gBAChC,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;gBACtB,IAAI,KAAK,CAAC,KAAK,KAAK,eAAe,CAAC,WAAW,EAAE;oBAC7C,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,yBAAyB,CAAC;wBAC3C,KAAK,EAAE,KAAK,CAAC,KAAK;wBAClB,gBAAgB,EAAE,KAAK,CAAC,iBAAiB;wBACzC,QAAQ,EAAE,KAAK,CAAC,SAAS;qBAC5B,CAAC,CAAC,CAAC;iBACP;aACJ;YAED,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/B,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAEM,eAAe,CAAC,QAAgB,EAAE,OAAe,EAAE,WAAmB;QACzE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACjB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EACjB;YACI,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAChC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY;YACxC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAC/B,UAAU,EAAE,2CAA2C;YACvD,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;YAC3C,SAAS,EAAE,QAAQ;YACnB,QAAQ,EAAE,OAAO;YACjB,YAAY,EAAE,WAAW;SAC5B,CACJ,CAAC;IACN,CAAC;IAEM,YAAY,CAAC,YAAoB;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACjB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EACjB;YACI,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAChC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY;YACxC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAC/B,UAAU,EAAE,eAAe;YAC3B,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;YAC3C,aAAa,EAAE,YAAY;SAC9B,CACJ,CAAC;IACN,CAAC;IAEM,kBAAkB,CAAC,YAAoB;QAC1C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACjB,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAClB;YACI,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAChC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY;YACxC,KAAK,EAAE,YAAY;SACtB,CACJ,CAAC;IACN,CAAC;;0GA1EQ,aAAa,kBACF,kBAAkB;8GAD7B,aAAa;2FAAb,aAAa;kBADzB,UAAU;;0BAEM,MAAM;2BAAC,kBAAkB","sourcesContent":["import { HttpClient, HttpErrorResponse } from \"@angular/common/http\";\nimport { Inject, Injectable } from \"@angular/core\";\nimport { Observable, throwError } from \"rxjs\";\nimport { catchError } from \"rxjs/operators\";\nimport { NICE_AUTH0_OPTIONS } from \"../../nice-auth0-kit.constant\";\nimport { NiceAuth0Options } from \"../../nice-auth0-kit.options\";\nimport { Auth0Api } from \"../auth0.api\";\nimport { Auth0MfaRequiredException } from \"./exceptions/mfa-required.exception\";\nimport { TokenExceptions } from \"./exceptions/token.exception\";\nimport { Auth0TokenResponse } from \"./models/token-response.model\";\n\n@Injectable()\nexport class Auth0TokenApi extends Auth0Api {\n    constructor(@Inject(NICE_AUTH0_OPTIONS) private options: NiceAuth0Options, private http: HttpClient) {\n        super(options.domain, \"oauth\");\n    }\n\n    public authWithPassword(username: string, password: string): Observable<Auth0TokenResponse> {\n        return this.http.post<Auth0TokenResponse>(\n            this.url(\"token\"),\n            {\n                client_id: this.options.clientId,\n                client_secret: this.options.clientSecret,\n                audience: this.options.audience,\n                grant_type: \"password\",\n                scope: this.options?.scopes.join(\" \") ?? \"\",\n                username,\n                password\n            }\n        ).pipe(\n            catchError((e) => {\n                if (e instanceof HttpErrorResponse) {\n                    const error = e.error;\n                    if (error.error === TokenExceptions.MfaRequired) {\n                        throwError(() => new Auth0MfaRequiredException({\n                            error: error.error,\n                            errorDescription: error.error_description,\n                            mfaToken: error.mfa_token\n                        }));\n                    }\n                }\n\n                return throwError(() => e);\n            })\n        );\n    }\n\n    public authWithOobCode(mfaToken: string, oobCode: string, bindingCode: string): Observable<Auth0TokenResponse> {\n        return this.http.post<Auth0TokenResponse>(\n            this.url(\"token\"),\n            {\n                client_id: this.options.clientId,\n                client_secret: this.options.clientSecret,\n                audience: this.options.audience,\n                grant_type: \"http://auth0.com/oauth/grant-type/mfa-oob\",\n                scope: this.options?.scopes.join(\" \") ?? \"\",\n                mfa_token: mfaToken,\n                oob_code: oobCode,\n                binding_code: bindingCode\n            }\n        );\n    }\n\n    public refreshToken(refreshToken: string): Observable<Auth0TokenResponse> {\n        return this.http.post<Auth0TokenResponse>(\n            this.url(\"token\"),\n            {\n                client_id: this.options.clientId,\n                client_secret: this.options.clientSecret,\n                audience: this.options.audience,\n                grant_type: \"refresh_token\",\n                scope: this.options?.scopes.join(\" \") ?? \"\",\n                refresh_token: refreshToken\n            }\n        );\n    }\n\n    public revokeRefreshToken(refreshToken: string): Observable<void> {\n        return this.http.post<void>(\n            this.url(\"revoke\"),\n            {\n                client_id: this.options.clientId,\n                client_secret: this.options.clientSecret,\n                token: refreshToken\n            }\n        );\n    }\n}\n"]}

package/esm2020/lib/nice-auht0-kit.module.mjs

@@ -0,0 +1,51 @@
+import { HTTP_INTERCEPTORS, HttpClientModule } from "@angular/common/http";
+import { NgModule } from "@angular/core";
+import { NiceAuthInterceptor } from "./api/interceptors/auth.interceptor";
+import { Auth0MfaApi } from "./api/mfa/mfa.api";
+import { NiceAuth0Service } from "./api/nice-auth0.service";
+import { Auth0TokenApi } from "./api/token/token.api";
+import { NICE_AUTH0_OPTIONS } from "./nice-auth0-kit.constant";
+import { NiceAuthenticationService } from "./providers/authentication.service";
+import * as i0 from "@angular/core";
+export class NiceAuth0Module {
+    static forRoot(options) {
+        return {
+            ngModule: NiceAuth0Module,
+            providers: [
+                {
+                    provide: NICE_AUTH0_OPTIONS,
+                    useValue: options
+                }
+            ]
+        };
+    }
+}
+NiceAuth0Module.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuth0Module, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NiceAuth0Module.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuth0Module, imports: [HttpClientModule] });
+NiceAuth0Module.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuth0Module, providers: [
+        Auth0MfaApi,
+        Auth0TokenApi,
+        NiceAuth0Service,
+        NiceAuthenticationService,
+        { provide: HTTP_INTERCEPTORS, useClass: NiceAuthInterceptor, multi: true }
+    ], imports: [[
+            HttpClientModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuth0Module, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        HttpClientModule
+                    ],
+                    declarations: [],
+                    providers: [
+                        Auth0MfaApi,
+                        Auth0TokenApi,
+                        NiceAuth0Service,
+                        NiceAuthenticationService,
+                        { provide: HTTP_INTERCEPTORS, useClass: NiceAuthInterceptor, multi: true }
+                    ],
+                    exports: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/nice-auth0-kit.constant.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from "@angular/core";
+export const NICE_AUTH0_OPTIONS = new InjectionToken("nice_auth0_options");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmljZS1hdXRoMC1raXQuY29uc3RhbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uaWNlLWF1dGgwLWtpdC9zcmMvbGliL25pY2UtYXV0aDAta2l0LmNvbnN0YW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0MsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxjQUFjLENBQUMsb0JBQW9CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcblxuZXhwb3J0IGNvbnN0IE5JQ0VfQVVUSDBfT1BUSU9OUyA9IG5ldyBJbmplY3Rpb25Ub2tlbihcIm5pY2VfYXV0aDBfb3B0aW9uc1wiKTtcbiJdfQ==

package/esm2020/lib/nice-auth0-kit.options.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmljZS1hdXRoMC1raXQub3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25pY2UtYXV0aDAta2l0L3NyYy9saWIvbmljZS1hdXRoMC1raXQub3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBOaWNlQXV0aDBPcHRpb25zIHtcbiAgICBkb21haW46IHN0cmluZztcbiAgICBjbGllbnRJZDogc3RyaW5nO1xuICAgIGNsaWVudFNlY3JldDogc3RyaW5nO1xuICAgIGF1ZGllbmNlOiBzdHJpbmc7XG4gICAgc2NvcGVzOiBzdHJpbmdbXTtcbn1cbiJdfQ==

package/esm2020/lib/providers/authentication.service.mjs

@@ -0,0 +1,148 @@
+import { Injectable } from "@angular/core";
+import jwtDecode from "jwt-decode";
+import { BehaviorSubject, of, throwError } from "rxjs";
+import { catchError, map, tap } from "rxjs/operators";
+import { NiceAuth0Service } from "../api/nice-auth0.service";
+import { Auth0MfaRequiredException } from "../api/token/exceptions/mfa-required.exception";
+import { NoAuthenticatorException } from "./exceptions/no-authenticator.exception";
+import * as i0 from "@angular/core";
+import * as i1 from "../api/nice-auth0.service";
+export class NiceAuthenticationService {
+    constructor(auth0Service) {
+        this.auth0Service = auth0Service;
+        this.currentUser$ = new BehaviorSubject(this.currentUser);
+    }
+    get idToken() {
+        return localStorage.getItem("auth0_id_token");
+    }
+    set idToken(accessToken) {
+        localStorage.setItem("auth0_id_token", accessToken);
+        this.currentUser$.next(this.currentUser);
+    }
+    get accessToken() {
+        return localStorage.getItem("auth0_access_token");
+    }
+    set accessToken(accessToken) {
+        localStorage.setItem("auth0_access_token", accessToken);
+    }
+    get refreshToken() {
+        return localStorage.getItem("auth0_refresh_token");
+    }
+    set refreshToken(refreshToken) {
+        localStorage.setItem("auth0_refresh_token", refreshToken);
+    }
+    get idTokenPayload() {
+        try {
+            return jwtDecode(this.idToken);
+        }
+        catch (e) {
+            console.log("Failed to decode payload: " + e);
+            return {};
+        }
+    }
+    get accessTokenPayload() {
+        try {
+            const decodedPayload = atob(this.accessToken.split(".")[1]);
+            return JSON.parse(decodedPayload);
+        }
+        catch (e) {
+            console.log("Failed to decode payload: " + e);
+            return {};
+        }
+    }
+    get currentUser() {
+        return this.idTokenPayload;
+    }
+    checkLoggedIn() {
+        if (this.validateToken()) {
+            return of(true);
+        }
+        return this.getAccessToken().pipe(map((accessToken) => accessToken != null), catchError(() => of(false)));
+    }
+    getAccessToken() {
+        if (!this.accessToken) {
+            return of(null);
+        }
+        if (this.validateToken()) {
+            return of(this.accessToken);
+        }
+        if (this.refreshToken) {
+            return this.generateNewToken();
+        }
+        return of(null);
+    }
+    validateToken() {
+        if (!this.accessToken) {
+            return false;
+        }
+        const exp = this.accessTokenPayload.exp;
+        const now = new Date().getTime() / 1000;
+        return now < exp;
+    }
+    passwordGrant(username, password) {
+        return this.auth0Service.token.authWithPassword(username, password).pipe(map(value => {
+            this.refreshToken = value.refresh_token;
+            this.idToken = value.id_token;
+            this.accessToken = value.access_token;
+            return {
+                success: true,
+                mfaRequired: false
+            };
+        }), catchError((e) => {
+            if (e instanceof Auth0MfaRequiredException) {
+                this.lastMfaChallengeToken = e.mfaToken;
+                return this.generateChallenge().pipe(map(() => ({
+                    success: true,
+                    mfaRequired: true
+                })), catchError(() => throwError(() => new NoAuthenticatorException())));
+            }
+            return throwError(() => e);
+        }));
+    }
+    validateOobCode(code) {
+        return this.auth0Service.token.authWithOobCode(this.lastMfaChallengeToken, this.lastMfaOobCode, code).pipe(map(value => {
+            this.refreshToken = value.refresh_token;
+            this.idToken = value.id_token;
+            this.accessToken = value.access_token;
+        }));
+    }
+    logout() {
+        const refreshToken = localStorage.getItem("auth0_refresh_token");
+        localStorage.removeItem("auth0_id_token");
+        localStorage.removeItem("auth0_access_token");
+        localStorage.removeItem("auth0_refresh_token");
+        return this.auth0Service.token.revokeRefreshToken(refreshToken);
+    }
+    generateNewToken() {
+        return this.auth0Service.token.refreshToken(this.refreshToken).pipe(tap(value => {
+            this.refreshToken = value.refresh_token;
+            this.idToken = value.id_token;
+            this.accessToken = value.access_token;
+        }), map(value => value.access_token), catchError(e => {
+            return of(null);
+        }));
+    }
+    addMfaAuthenticator(authenticator) {
+        return this.auth0Service.mfa.associateOobAuthenticator({
+            channels: [authenticator.type],
+            email: authenticator.email,
+            phoneNumber: authenticator.phoneNumber
+        }).pipe(map(value => {
+            this.lastMfaOobCode = value.oob_code;
+        }));
+    }
+    generateChallenge() {
+        return this.auth0Service.mfa.challenge({
+            type: "oob",
+            mfaToken: this.lastMfaChallengeToken
+        }).pipe(map(value => {
+            this.lastMfaOobCode = value.oob_code;
+        }));
+    }
+}
+NiceAuthenticationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuthenticationService, deps: [{ token: i1.NiceAuth0Service }], target: i0.ɵɵFactoryTarget.Injectable });
+NiceAuthenticationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuthenticationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceAuthenticationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.NiceAuth0Service }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication.service.js","sourceRoot":"","sources":["../../../../../projects/nice-auth0-kit/src/lib/providers/authentication.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport jwtDecode from \"jwt-decode\";\nimport { BehaviorSubject, Observable, of, throwError } from \"rxjs\";\nimport { catchError, map, tap } from \"rxjs/operators\";\nimport { NiceAuth0Service } from \"../api/nice-auth0.service\";\nimport { Auth0MfaRequiredException } from \"../api/token/exceptions/mfa-required.exception\";\nimport { NoAuthenticatorException } from \"./exceptions/no-authenticator.exception\";\n\nexport interface LoginResponse {\n    success: boolean;\n    mfaRequired: boolean;\n}\n\nexport interface SmsAuthenticator {\n    type: \"sms\";\n    phoneNumber: string;\n}\n\nexport interface EmailAuthenticator {\n    type: \"email\";\n    email: string;\n}\n\n@Injectable()\nexport class NiceAuthenticationService {\n    private lastMfaChallengeToken: string;\n    private lastMfaOobCode: string;\n\n    public currentUser$ = new BehaviorSubject(this.currentUser);\n\n    constructor(private auth0Service: NiceAuth0Service) {}\n\n    public get idToken(): string {\n        return localStorage.getItem(\"auth0_id_token\");\n    }\n\n    public set idToken(accessToken: string) {\n        localStorage.setItem(\"auth0_id_token\", accessToken);\n        this.currentUser$.next(this.currentUser);\n    }\n\n    public get accessToken(): string {\n        return localStorage.getItem(\"auth0_access_token\");\n    }\n\n    public set accessToken(accessToken: string) {\n        localStorage.setItem(\"auth0_access_token\", accessToken);\n    }\n\n    public get refreshToken(): string {\n        return localStorage.getItem(\"auth0_refresh_token\");\n    }\n\n    public set refreshToken(refreshToken: string) {\n        localStorage.setItem(\"auth0_refresh_token\", refreshToken);\n    }\n\n    public get idTokenPayload(): any {\n        try {\n            return jwtDecode(this.idToken);\n        } catch (e) {\n            console.log(\"Failed to decode payload: \" + e);\n            return {};\n        }\n    }\n\n    public get accessTokenPayload(): any {\n        try {\n            const decodedPayload = atob(this.accessToken.split(\".\")[1]);\n            return JSON.parse(decodedPayload);\n        } catch (e) {\n            console.log(\"Failed to decode payload: \" + e);\n            return {};\n        }\n    }\n\n    public get currentUser(): any {\n        return this.idTokenPayload;\n    }\n\n    public checkLoggedIn(): Observable<boolean> {\n        if (this.validateToken()) {\n            return of(true);\n        }\n\n        return this.getAccessToken().pipe(\n            map((accessToken: string) => accessToken != null),\n            catchError(() => of(false))\n        );\n    }\n\n    public getAccessToken(): Observable<string> {\n        if (!this.accessToken) {\n            return of(null);\n        }\n\n        if (this.validateToken()) {\n            return of(this.accessToken);\n        }\n\n        if (this.refreshToken) {\n            return this.generateNewToken();\n        }\n\n        return of(null);\n    }\n\n    public validateToken(): boolean {\n        if (!this.accessToken) {\n            return false;\n        }\n\n        const exp = this.accessTokenPayload.exp;\n        const now = new Date().getTime() / 1000;\n        return now < exp;\n    }\n\n    public passwordGrant(username: string, password: string): Observable<LoginResponse> {\n        return this.auth0Service.token.authWithPassword(username, password).pipe(\n            map(value => {\n                this.refreshToken = value.refresh_token;\n                this.idToken = value.id_token;\n                this.accessToken = value.access_token;\n                return {\n                    success: true,\n                    mfaRequired: false\n                };\n            }),\n            catchError((e) => {\n                if (e instanceof Auth0MfaRequiredException) {\n                    this.lastMfaChallengeToken = e.mfaToken;\n                    return this.generateChallenge().pipe(\n                        map(() => ({\n                            success: true,\n                            mfaRequired: true\n                        })),\n                        catchError(() => throwError(() => new NoAuthenticatorException()))\n                    );\n                }\n                return throwError(() => e);\n            }),\n        );\n    }\n\n    public validateOobCode(code: string): Observable<void> {\n        return this.auth0Service.token.authWithOobCode(this.lastMfaChallengeToken, this.lastMfaOobCode, code).pipe(\n            map(value => {\n                this.refreshToken = value.refresh_token;\n                this.idToken = value.id_token;\n                this.accessToken = value.access_token;\n            })\n        );\n    }\n\n    public logout(): Observable<void> {\n        const refreshToken = localStorage.getItem(\"auth0_refresh_token\");\n\n        localStorage.removeItem(\"auth0_id_token\");\n        localStorage.removeItem(\"auth0_access_token\");\n        localStorage.removeItem(\"auth0_refresh_token\");\n\n        return this.auth0Service.token.revokeRefreshToken(refreshToken);\n    }\n\n    public generateNewToken(): Observable<string> {\n        return this.auth0Service.token.refreshToken(this.refreshToken).pipe(\n            tap(value => {\n                this.refreshToken = value.refresh_token;\n                this.idToken = value.id_token;\n                this.accessToken = value.access_token;\n            }),\n            map(value => value.access_token),\n            catchError(e => {\n                return of(null);\n            })\n        );\n    }\n\n    public addMfaAuthenticator(authenticator: SmsAuthenticator | EmailAuthenticator): Observable<void> {\n        return this.auth0Service.mfa.associateOobAuthenticator({\n            channels: [authenticator.type],\n            email: (authenticator as EmailAuthenticator).email,\n            phoneNumber: (authenticator as SmsAuthenticator).phoneNumber\n        }).pipe(\n            map(value => {\n                this.lastMfaOobCode = value.oob_code;\n            })\n        );\n    }\n\n    private generateChallenge(): Observable<void> {\n        return this.auth0Service.mfa.challenge({\n            type: \"oob\",\n            mfaToken: this.lastMfaChallengeToken\n        }).pipe(\n            map(value => {\n                this.lastMfaOobCode = value.oob_code;\n            })\n        );\n    }\n}\n"]}

package/esm2020/lib/providers/exceptions/no-authenticator.exception.mjs

@@ -0,0 +1,3 @@
+export class NoAuthenticatorException {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm8tYXV0aGVudGljYXRvci5leGNlcHRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uaWNlLWF1dGgwLWtpdC9zcmMvbGliL3Byb3ZpZGVycy9leGNlcHRpb25zL25vLWF1dGhlbnRpY2F0b3IuZXhjZXB0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyx3QkFBd0I7Q0FBRyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBOb0F1dGhlbnRpY2F0b3JFeGNlcHRpb24ge31cbiJdfQ==