@nebular/auth/esm2020/services/auth.service.mjs

/**
 * @license
 * Copyright Akveo. All Rights Reserved.
 * Licensed under the MIT License. See License.txt in the project root for license information.
 */
import { Inject, Injectable } from '@angular/core';
import { of as observableOf } from 'rxjs';
import { switchMap, map } from 'rxjs/operators';
import { NB_AUTH_STRATEGIES } from '../auth.options';
import * as i0 from "@angular/core";
import * as i1 from "./token/token.service";
/**
 * Common authentication service.
 * Should be used to as an interlayer between UI Components and Auth Strategy.
 */
export class NbAuthService {
    constructor(tokenService, strategies) {
        this.tokenService = tokenService;
        this.strategies = strategies;
    }
    /**
     * Retrieves current authenticated token stored
     * @returns {Observable<any>}
     */
    getToken() {
        return this.tokenService.get();
    }
    /**
     * Returns true if auth token is present in the token storage
     * @returns {Observable<boolean>}
     */
    isAuthenticated() {
        return this.getToken()
            .pipe(map((token) => token.isValid()));
    }
    /**
     * Returns true if valid auth token is present in the token storage.
     * If not, calls the strategy refreshToken, and returns isAuthenticated() if success, false otherwise
     * @returns {Observable<boolean>}
     */
    isAuthenticatedOrRefresh() {
        return this.getToken()
            .pipe(switchMap(token => {
            if (token.getValue() && !token.isValid()) {
                return this.refreshToken(token.getOwnerStrategyName(), token)
                    .pipe(switchMap(res => {
                    if (res.isSuccess()) {
                        return this.isAuthenticated();
                    }
                    else {
                        return observableOf(false);
                    }
                }));
            }
            else {
                return observableOf(token.isValid());
            }
        }));
    }
    /**
     * Returns tokens stream
     * @returns {Observable<NbAuthSimpleToken>}
     */
    onTokenChange() {
        return this.tokenService.tokenChange();
    }
    /**
     * Returns authentication status stream
     * @returns {Observable<boolean>}
     */
    onAuthenticationChange() {
        return this.onTokenChange()
            .pipe(map((token) => token.isValid()));
    }
    /**
     * Authenticates with the selected strategy
     * Stores received token in the token storage
     *
     * Example:
     * authenticate('email', {email: 'email@example.com', password: 'test'})
     *
     * @param strategyName
     * @param data
     * @returns {Observable<NbAuthResult>}
     */
    authenticate(strategyName, data) {
        return this.getStrategy(strategyName).authenticate(data)
            .pipe(switchMap((result) => {
            return this.processResultToken(result);
        }));
    }
    /**
     * Registers with the selected strategy
     * Stores received token in the token storage
     *
     * Example:
     * register('email', {email: 'email@example.com', name: 'Some Name', password: 'test'})
     *
     * @param strategyName
     * @param data
     * @returns {Observable<NbAuthResult>}
     */
    register(strategyName, data) {
        return this.getStrategy(strategyName).register(data)
            .pipe(switchMap((result) => {
            return this.processResultToken(result);
        }));
    }
    /**
     * Sign outs with the selected strategy
     * Removes token from the token storage
     *
     * Example:
     * logout('email')
     *
     * @param strategyName
     * @returns {Observable<NbAuthResult>}
     */
    logout(strategyName) {
        return this.getStrategy(strategyName).logout()
            .pipe(switchMap((result) => {
            if (result.isSuccess()) {
                this.tokenService.clear()
                    .pipe(map(() => result));
            }
            return observableOf(result);
        }));
    }
    /**
     * Sends forgot password request to the selected strategy
     *
     * Example:
     * requestPassword('email', {email: 'email@example.com'})
     *
     * @param strategyName
     * @param data
     * @returns {Observable<NbAuthResult>}
     */
    requestPassword(strategyName, data) {
        return this.getStrategy(strategyName).requestPassword(data);
    }
    /**
     * Tries to reset password with the selected strategy
     *
     * Example:
     * resetPassword('email', {newPassword: 'test'})
     *
     * @param strategyName
     * @param data
     * @returns {Observable<NbAuthResult>}
     */
    resetPassword(strategyName, data) {
        return this.getStrategy(strategyName).resetPassword(data);
    }
    /**
     * Sends a refresh token request
     * Stores received token in the token storage
     *
     * Example:
     * refreshToken('email', {token: token})
     *
     * @param {string} strategyName
     * @param data
     * @returns {Observable<NbAuthResult>}
     */
    refreshToken(strategyName, data) {
        return this.getStrategy(strategyName).refreshToken(data)
            .pipe(switchMap((result) => {
            return this.processResultToken(result);
        }));
    }
    /**
     * Get registered strategy by name
     *
     * Example:
     * getStrategy('email')
     *
     * @param {string} provider
     * @returns {NbAbstractAuthProvider}
     */
    getStrategy(strategyName) {
        const found = this.strategies.find((strategy) => strategy.getName() === strategyName);
        if (!found) {
            throw new TypeError(`There is no Auth Strategy registered under '${strategyName}' name`);
        }
        return found;
    }
    processResultToken(result) {
        if (result.isSuccess() && result.getToken()) {
            return this.tokenService.set(result.getToken())
                .pipe(map((token) => {
                return result;
            }));
        }
        return observableOf(result);
    }
}
NbAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NbAuthService, deps: [{ token: i1.NbTokenService }, { token: NB_AUTH_STRATEGIES }], target: i0.ɵɵFactoryTarget.Injectable });
NbAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NbAuthService });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: NbAuthService, decorators: [{
            type: Injectable
        }], ctorParameters: function () { return [{ type: i1.NbTokenService }, { type: undefined, decorators: [{
                    type: Inject,
                    args: [NB_AUTH_STRATEGIES]
                }] }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../src/framework/auth/services/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Akveo. All Rights Reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n */\nimport { Inject, Injectable } from '@angular/core';\n\nimport { Observable, of as observableOf } from 'rxjs';\nimport { switchMap, map } from 'rxjs/operators';\n\nimport { NbAuthStrategy } from '../strategies/auth-strategy';\nimport { NB_AUTH_STRATEGIES } from '../auth.options';\nimport { NbAuthResult } from './auth-result';\nimport { NbTokenService } from './token/token.service';\nimport { NbAuthToken } from './token/token';\n\n/**\n * Common authentication service.\n * Should be used to as an interlayer between UI Components and Auth Strategy.\n */\n@Injectable()\nexport class NbAuthService {\n\n  constructor(protected tokenService: NbTokenService,\n              @Inject(NB_AUTH_STRATEGIES) protected strategies) {\n  }\n\n  /**\n   * Retrieves current authenticated token stored\n   * @returns {Observable<any>}\n   */\n  getToken(): Observable<NbAuthToken> {\n    return this.tokenService.get();\n  }\n\n  /**\n   * Returns true if auth token is present in the token storage\n   * @returns {Observable<boolean>}\n   */\n  isAuthenticated(): Observable<boolean> {\n    return this.getToken()\n      .pipe(map((token: NbAuthToken) => token.isValid()));\n  }\n\n  /**\n   * Returns true if valid auth token is present in the token storage.\n   * If not, calls the strategy refreshToken, and returns isAuthenticated() if success, false otherwise\n   * @returns {Observable<boolean>}\n   */\n  isAuthenticatedOrRefresh(): Observable<boolean> {\n    return this.getToken()\n      .pipe(\n        switchMap(token => {\n        if (token.getValue() && !token.isValid()) {\n          return this.refreshToken(token.getOwnerStrategyName(), token)\n            .pipe(\n              switchMap(res => {\n                if (res.isSuccess()) {\n                  return this.isAuthenticated();\n                } else {\n                  return observableOf(false);\n                }\n              }),\n            )\n        } else {\n          return observableOf(token.isValid());\n        }\n    }));\n  }\n\n  /**\n   * Returns tokens stream\n   * @returns {Observable<NbAuthSimpleToken>}\n   */\n  onTokenChange(): Observable<NbAuthToken> {\n    return this.tokenService.tokenChange();\n  }\n\n  /**\n   * Returns authentication status stream\n   * @returns {Observable<boolean>}\n   */\n  onAuthenticationChange(): Observable<boolean> {\n    return this.onTokenChange()\n      .pipe(map((token: NbAuthToken) => token.isValid()));\n  }\n\n  /**\n   * Authenticates with the selected strategy\n   * Stores received token in the token storage\n   *\n   * Example:\n   * authenticate('email', {email: 'email@example.com', password: 'test'})\n   *\n   * @param strategyName\n   * @param data\n   * @returns {Observable<NbAuthResult>}\n   */\n  authenticate(strategyName: string, data?: any): Observable<NbAuthResult> {\n    return this.getStrategy(strategyName).authenticate(data)\n      .pipe(\n        switchMap((result: NbAuthResult) => {\n          return this.processResultToken(result);\n        }),\n      );\n  }\n\n  /**\n   * Registers with the selected strategy\n   * Stores received token in the token storage\n   *\n   * Example:\n   * register('email', {email: 'email@example.com', name: 'Some Name', password: 'test'})\n   *\n   * @param strategyName\n   * @param data\n   * @returns {Observable<NbAuthResult>}\n   */\n  register(strategyName: string, data?: any): Observable<NbAuthResult> {\n    return this.getStrategy(strategyName).register(data)\n      .pipe(\n        switchMap((result: NbAuthResult) => {\n          return this.processResultToken(result);\n        }),\n      );\n  }\n\n  /**\n   * Sign outs with the selected strategy\n   * Removes token from the token storage\n   *\n   * Example:\n   * logout('email')\n   *\n   * @param strategyName\n   * @returns {Observable<NbAuthResult>}\n   */\n  logout(strategyName: string): Observable<NbAuthResult> {\n    return this.getStrategy(strategyName).logout()\n      .pipe(\n        switchMap((result: NbAuthResult) => {\n          if (result.isSuccess()) {\n            this.tokenService.clear()\n              .pipe(map(() => result));\n          }\n          return observableOf(result);\n        }),\n      );\n  }\n\n  /**\n   * Sends forgot password request to the selected strategy\n   *\n   * Example:\n   * requestPassword('email', {email: 'email@example.com'})\n   *\n   * @param strategyName\n   * @param data\n   * @returns {Observable<NbAuthResult>}\n   */\n  requestPassword(strategyName: string, data?: any): Observable<NbAuthResult> {\n    return this.getStrategy(strategyName).requestPassword(data);\n  }\n\n  /**\n   * Tries to reset password with the selected strategy\n   *\n   * Example:\n   * resetPassword('email', {newPassword: 'test'})\n   *\n   * @param strategyName\n   * @param data\n   * @returns {Observable<NbAuthResult>}\n   */\n  resetPassword(strategyName: string, data?: any): Observable<NbAuthResult> {\n    return this.getStrategy(strategyName).resetPassword(data);\n  }\n\n  /**\n   * Sends a refresh token request\n   * Stores received token in the token storage\n   *\n   * Example:\n   * refreshToken('email', {token: token})\n   *\n   * @param {string} strategyName\n   * @param data\n   * @returns {Observable<NbAuthResult>}\n   */\n  refreshToken(strategyName: string, data?: any): Observable<NbAuthResult> {\n    return this.getStrategy(strategyName).refreshToken(data)\n      .pipe(\n        switchMap((result: NbAuthResult) => {\n          return this.processResultToken(result);\n        }),\n      );\n  }\n\n  /**\n   * Get registered strategy by name\n   *\n   * Example:\n   * getStrategy('email')\n   *\n   * @param {string} provider\n   * @returns {NbAbstractAuthProvider}\n   */\n  protected getStrategy(strategyName: string): NbAuthStrategy {\n    const found = this.strategies.find((strategy: NbAuthStrategy) => strategy.getName() === strategyName);\n\n    if (!found) {\n      throw new TypeError(`There is no Auth Strategy registered under '${strategyName}' name`);\n    }\n\n    return found;\n  }\n\n  private processResultToken(result: NbAuthResult) {\n    if (result.isSuccess() && result.getToken()) {\n      return this.tokenService.set(result.getToken())\n        .pipe(\n          map((token: NbAuthToken) => {\n            return result;\n          }),\n        );\n    }\n\n    return observableOf(result);\n  }\n}\n"]}