@nebular/auth
Version:
@nebular/auth
270 lines • 37.4 kB
JavaScript
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
import { Injectable } from '@angular/core';
import { HttpErrorResponse } from '@angular/common/http';
import { of as observableOf } from 'rxjs';
import { switchMap, map, catchError } from 'rxjs/operators';
import { NbAuthResult } from '../../services/auth-result';
import { NbAuthStrategy } from '../auth-strategy';
import { passwordStrategyOptions } from './password-strategy-options';
import { NbAuthIllegalTokenError } from '../../services/token/token';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
import * as i2 from "@angular/router";
/**
* The most common authentication provider for email/password strategy.
*
* Strategy settings. Note, there is no need to copy over the whole object to change the settings you need.
* Also, this.getOption call won't work outside of the default options declaration
* (which is inside of the `NbPasswordAuthStrategy` class), so you have to replace it with a custom helper function
* if you need it.
*
* ```ts
*export class NbPasswordAuthStrategyOptions extends NbAuthStrategyOptions {
* name: string;
* baseEndpoint? = '/api/auth/';
* login?: boolean | NbPasswordStrategyModule = {
* alwaysFail: false,
* endpoint: 'login',
* method: 'post',
* requireValidToken: true,
* redirect: {
* success: '/',
* failure: null,
* },
* defaultErrors: ['Login/Email combination is not correct, please try again.'],
* defaultMessages: ['You have been successfully logged in.'],
* };
* register?: boolean | NbPasswordStrategyModule = {
* alwaysFail: false,
* endpoint: 'register',
* method: 'post',
* requireValidToken: true,
* redirect: {
* success: '/',
* failure: null,
* },
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['You have been successfully registered.'],
* };
* requestPass?: boolean | NbPasswordStrategyModule = {
* endpoint: 'request-pass',
* method: 'post',
* redirect: {
* success: '/',
* failure: null,
* },
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['Reset password instructions have been sent to your email.'],
* };
* resetPass?: boolean | NbPasswordStrategyReset = {
* endpoint: 'reset-pass',
* method: 'put',
* redirect: {
* success: '/',
* failure: null,
* },
* resetPasswordTokenKey: 'reset_password_token',
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['Your password has been successfully changed.'],
* };
* logout?: boolean | NbPasswordStrategyReset = {
* alwaysFail: false,
* endpoint: 'logout',
* method: 'delete',
* redirect: {
* success: '/',
* failure: null,
* },
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['You have been successfully logged out.'],
* };
* refreshToken?: boolean | NbPasswordStrategyModule = {
* endpoint: 'refresh-token',
* method: 'post',
* requireValidToken: true,
* redirect: {
* success: null,
* failure: null,
* },
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['Your token has been successfully refreshed.'],
* };
* token?: NbPasswordStrategyToken = {
* class: NbAuthSimpleToken,
* key: 'data.token',
* getter: (module: string, res: HttpResponse<Object>, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(
* res.body,
* options.token.key,
* ),
* };
* errors?: NbPasswordStrategyMessage = {
* key: 'data.errors',
* getter: (module: string, res: HttpErrorResponse, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(
* res.error,
* options.errors.key,
* options[module].defaultErrors,
* ),
* };
* messages?: NbPasswordStrategyMessage = {
* key: 'data.messages',
* getter: (module: string, res: HttpResponse<Object>, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(
* res.body,
* options.messages.key,
* options[module].defaultMessages,
* ),
* };
* validation?: {
* password?: {
* required?: boolean;
* minLength?: number | null;
* maxLength?: number | null;
* regexp?: string | null;
* };
* email?: {
* required?: boolean;
* regexp?: string | null;
* };
* fullName?: {
* required?: boolean;
* minLength?: number | null;
* maxLength?: number | null;
* regexp?: string | null;
* };
* };
*}
* ```
*/
export class NbPasswordAuthStrategy extends NbAuthStrategy {
constructor(http, route) {
super();
this.http = http;
this.route = route;
this.defaultOptions = passwordStrategyOptions;
}
static setup(options) {
return [NbPasswordAuthStrategy, options];
}
authenticate(data) {
const module = 'login';
const method = this.getOption(`${module}.method`);
const url = this.getActionEndpoint(module);
const requireValidToken = this.getOption(`${module}.requireValidToken`);
return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(map((res) => {
if (this.getOption(`${module}.alwaysFail`)) {
throw this.createFailResponse(data);
}
return res;
}), map((res) => {
return new NbAuthResult(true, res, this.getOption(`${module}.redirect.success`), [], this.getOption('messages.getter')(module, res, this.options), this.createToken(this.getOption('token.getter')(module, res, this.options), requireValidToken));
}), catchError((res) => {
return this.handleResponseError(res, module);
}));
}
register(data) {
const module = 'register';
const method = this.getOption(`${module}.method`);
const url = this.getActionEndpoint(module);
const requireValidToken = this.getOption(`${module}.requireValidToken`);
return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(map((res) => {
if (this.getOption(`${module}.alwaysFail`)) {
throw this.createFailResponse(data);
}
return res;
}), map((res) => {
return new NbAuthResult(true, res, this.getOption(`${module}.redirect.success`), [], this.getOption('messages.getter')(module, res, this.options), this.createToken(this.getOption('token.getter')('login', res, this.options), requireValidToken));
}), catchError((res) => {
return this.handleResponseError(res, module);
}));
}
requestPassword(data) {
const module = 'requestPass';
const method = this.getOption(`${module}.method`);
const url = this.getActionEndpoint(module);
return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(map((res) => {
if (this.getOption(`${module}.alwaysFail`)) {
throw this.createFailResponse();
}
return res;
}), map((res) => {
return new NbAuthResult(true, res, this.getOption(`${module}.redirect.success`), [], this.getOption('messages.getter')(module, res, this.options));
}), catchError((res) => {
return this.handleResponseError(res, module);
}));
}
resetPassword(data = {}) {
const module = 'resetPass';
const method = this.getOption(`${module}.method`);
const url = this.getActionEndpoint(module);
const tokenKey = this.getOption(`${module}.resetPasswordTokenKey`);
data[tokenKey] = this.route.snapshot.queryParams[tokenKey];
return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(map((res) => {
if (this.getOption(`${module}.alwaysFail`)) {
throw this.createFailResponse();
}
return res;
}), map((res) => {
return new NbAuthResult(true, res, this.getOption(`${module}.redirect.success`), [], this.getOption('messages.getter')(module, res, this.options));
}), catchError((res) => {
return this.handleResponseError(res, module);
}));
}
logout() {
const module = 'logout';
const method = this.getOption(`${module}.method`);
const url = this.getActionEndpoint(module);
return observableOf({}).pipe(switchMap((res) => {
if (!url) {
return observableOf(res);
}
return this.http.request(method, url, { observe: 'response', headers: this.getHeaders() });
}), map((res) => {
if (this.getOption(`${module}.alwaysFail`)) {
throw this.createFailResponse();
}
return res;
}), map((res) => {
return new NbAuthResult(true, res, this.getOption(`${module}.redirect.success`), [], this.getOption('messages.getter')(module, res, this.options));
}), catchError((res) => {
return this.handleResponseError(res, module);
}));
}
refreshToken(data) {
const module = 'refreshToken';
const method = this.getOption(`${module}.method`);
const url = this.getActionEndpoint(module);
const requireValidToken = this.getOption(`${module}.requireValidToken`);
return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(map((res) => {
if (this.getOption(`${module}.alwaysFail`)) {
throw this.createFailResponse(data);
}
return res;
}), map((res) => {
return new NbAuthResult(true, res, this.getOption(`${module}.redirect.success`), [], this.getOption('messages.getter')(module, res, this.options), this.createToken(this.getOption('token.getter')(module, res, this.options), requireValidToken));
}), catchError((res) => {
return this.handleResponseError(res, module);
}));
}
handleResponseError(res, module) {
let errors = [];
if (res instanceof HttpErrorResponse) {
errors = this.getOption('errors.getter')(module, res, this.options);
}
else if (res instanceof NbAuthIllegalTokenError) {
errors.push(res.message);
}
else {
errors.push('Something went wrong.');
}
return observableOf(new NbAuthResult(false, res, this.getOption(`${module}.redirect.failure`), errors));
}
}
NbPasswordAuthStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: NbPasswordAuthStrategy, deps: [{ token: i1.HttpClient }, { token: i2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
NbPasswordAuthStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: NbPasswordAuthStrategy });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: NbPasswordAuthStrategy, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ActivatedRoute }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"password-strategy.js","sourceRoot":"","sources":["../../../../../src/framework/auth/strategies/password/password-strategy.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 { Injectable } from '@angular/core';\nimport { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { ActivatedRoute } from '@angular/router';\nimport { Observable, of as observableOf } from 'rxjs';\nimport { switchMap, map, catchError } from 'rxjs/operators';\n\nimport { NbAuthResult } from '../../services/auth-result';\nimport { NbAuthStrategy } from '../auth-strategy';\nimport { NbAuthStrategyClass } from '../../auth.options';\nimport { NbPasswordAuthStrategyOptions, passwordStrategyOptions } from './password-strategy-options';\nimport { NbAuthIllegalTokenError } from '../../services/token/token';\n\n/**\n * The most common authentication provider for email/password strategy.\n *\n * Strategy settings. Note, there is no need to copy over the whole object to change the settings you need.\n * Also, this.getOption call won't work outside of the default options declaration\n * (which is inside of the `NbPasswordAuthStrategy` class), so you have to replace it with a custom helper function\n * if you need it.\n *\n * ```ts\n *export class NbPasswordAuthStrategyOptions extends NbAuthStrategyOptions {\n *  name: string;\n *  baseEndpoint? = '/api/auth/';\n *  login?: boolean | NbPasswordStrategyModule = {\n *    alwaysFail: false,\n *    endpoint: 'login',\n *    method: 'post',\n *    requireValidToken: true,\n *    redirect: {\n *      success: '/',\n *      failure: null,\n *    },\n *    defaultErrors: ['Login/Email combination is not correct, please try again.'],\n *    defaultMessages: ['You have been successfully logged in.'],\n *  };\n *  register?: boolean | NbPasswordStrategyModule = {\n *    alwaysFail: false,\n *    endpoint: 'register',\n *    method: 'post',\n *    requireValidToken: true,\n *    redirect: {\n *      success: '/',\n *      failure: null,\n *    },\n *    defaultErrors: ['Something went wrong, please try again.'],\n *    defaultMessages: ['You have been successfully registered.'],\n *  };\n *  requestPass?: boolean | NbPasswordStrategyModule = {\n *    endpoint: 'request-pass',\n *    method: 'post',\n *    redirect: {\n *      success: '/',\n *      failure: null,\n *    },\n *    defaultErrors: ['Something went wrong, please try again.'],\n *    defaultMessages: ['Reset password instructions have been sent to your email.'],\n *  };\n *  resetPass?: boolean | NbPasswordStrategyReset = {\n *    endpoint: 'reset-pass',\n *    method: 'put',\n *    redirect: {\n *      success: '/',\n *      failure: null,\n *    },\n *    resetPasswordTokenKey: 'reset_password_token',\n *    defaultErrors: ['Something went wrong, please try again.'],\n *    defaultMessages: ['Your password has been successfully changed.'],\n *  };\n *  logout?: boolean | NbPasswordStrategyReset = {\n *    alwaysFail: false,\n *    endpoint: 'logout',\n *    method: 'delete',\n *    redirect: {\n *      success: '/',\n *      failure: null,\n *    },\n *    defaultErrors: ['Something went wrong, please try again.'],\n *    defaultMessages: ['You have been successfully logged out.'],\n *  };\n *  refreshToken?: boolean | NbPasswordStrategyModule = {\n *    endpoint: 'refresh-token',\n *    method: 'post',\n *    requireValidToken: true,\n *    redirect: {\n *      success: null,\n *      failure: null,\n *    },\n *    defaultErrors: ['Something went wrong, please try again.'],\n *    defaultMessages: ['Your token has been successfully refreshed.'],\n *  };\n *  token?: NbPasswordStrategyToken = {\n *    class: NbAuthSimpleToken,\n *    key: 'data.token',\n *    getter: (module: string, res: HttpResponse<Object>, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(\n *      res.body,\n *      options.token.key,\n *    ),\n *  };\n *  errors?: NbPasswordStrategyMessage = {\n *    key: 'data.errors',\n *    getter: (module: string, res: HttpErrorResponse, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(\n *      res.error,\n *      options.errors.key,\n *      options[module].defaultErrors,\n *    ),\n *  };\n *  messages?: NbPasswordStrategyMessage = {\n *    key: 'data.messages',\n *    getter: (module: string, res: HttpResponse<Object>, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(\n *      res.body,\n *      options.messages.key,\n *      options[module].defaultMessages,\n *    ),\n *  };\n *  validation?: {\n *    password?: {\n *      required?: boolean;\n *      minLength?: number | null;\n *      maxLength?: number | null;\n *      regexp?: string | null;\n *    };\n *    email?: {\n *      required?: boolean;\n *      regexp?: string | null;\n *    };\n *    fullName?: {\n *      required?: boolean;\n *      minLength?: number | null;\n *      maxLength?: number | null;\n *      regexp?: string | null;\n *    };\n *  };\n *}\n * ```\n */\n@Injectable()\nexport class NbPasswordAuthStrategy extends NbAuthStrategy {\n  protected defaultOptions: NbPasswordAuthStrategyOptions = passwordStrategyOptions;\n\n  static setup(options: NbPasswordAuthStrategyOptions): [NbAuthStrategyClass, NbPasswordAuthStrategyOptions] {\n    return [NbPasswordAuthStrategy, options];\n  }\n\n  constructor(protected http: HttpClient, private route: ActivatedRoute) {\n    super();\n  }\n\n  authenticate(data?: any): Observable<NbAuthResult> {\n    const module = 'login';\n    const method = this.getOption(`${module}.method`);\n    const url = this.getActionEndpoint(module);\n    const requireValidToken = this.getOption(`${module}.requireValidToken`);\n    return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(\n      map((res) => {\n        if (this.getOption(`${module}.alwaysFail`)) {\n          throw this.createFailResponse(data);\n        }\n        return res;\n      }),\n      map((res) => {\n        return new NbAuthResult(\n          true,\n          res,\n          this.getOption(`${module}.redirect.success`),\n          [],\n          this.getOption('messages.getter')(module, res, this.options),\n          this.createToken(this.getOption('token.getter')(module, res, this.options), requireValidToken),\n        );\n      }),\n      catchError((res) => {\n        return this.handleResponseError(res, module);\n      }),\n    );\n  }\n\n  register(data?: any): Observable<NbAuthResult> {\n    const module = 'register';\n    const method = this.getOption(`${module}.method`);\n    const url = this.getActionEndpoint(module);\n    const requireValidToken = this.getOption(`${module}.requireValidToken`);\n    return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(\n      map((res) => {\n        if (this.getOption(`${module}.alwaysFail`)) {\n          throw this.createFailResponse(data);\n        }\n\n        return res;\n      }),\n      map((res) => {\n        return new NbAuthResult(\n          true,\n          res,\n          this.getOption(`${module}.redirect.success`),\n          [],\n          this.getOption('messages.getter')(module, res, this.options),\n          this.createToken(this.getOption('token.getter')('login', res, this.options), requireValidToken),\n        );\n      }),\n      catchError((res) => {\n        return this.handleResponseError(res, module);\n      }),\n    );\n  }\n\n  requestPassword(data?: any): Observable<NbAuthResult> {\n    const module = 'requestPass';\n    const method = this.getOption(`${module}.method`);\n    const url = this.getActionEndpoint(module);\n    return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(\n      map((res) => {\n        if (this.getOption(`${module}.alwaysFail`)) {\n          throw this.createFailResponse();\n        }\n\n        return res;\n      }),\n      map((res) => {\n        return new NbAuthResult(\n          true,\n          res,\n          this.getOption(`${module}.redirect.success`),\n          [],\n          this.getOption('messages.getter')(module, res, this.options),\n        );\n      }),\n      catchError((res) => {\n        return this.handleResponseError(res, module);\n      }),\n    );\n  }\n\n  resetPassword(data: any = {}): Observable<NbAuthResult> {\n    const module = 'resetPass';\n    const method = this.getOption(`${module}.method`);\n    const url = this.getActionEndpoint(module);\n    const tokenKey = this.getOption(`${module}.resetPasswordTokenKey`);\n    data[tokenKey] = this.route.snapshot.queryParams[tokenKey];\n    return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(\n      map((res) => {\n        if (this.getOption(`${module}.alwaysFail`)) {\n          throw this.createFailResponse();\n        }\n\n        return res;\n      }),\n      map((res) => {\n        return new NbAuthResult(\n          true,\n          res,\n          this.getOption(`${module}.redirect.success`),\n          [],\n          this.getOption('messages.getter')(module, res, this.options),\n        );\n      }),\n      catchError((res) => {\n        return this.handleResponseError(res, module);\n      }),\n    );\n  }\n\n  logout(): Observable<NbAuthResult> {\n    const module = 'logout';\n    const method = this.getOption(`${module}.method`);\n    const url = this.getActionEndpoint(module);\n\n    return observableOf({}).pipe(\n      switchMap((res: any) => {\n        if (!url) {\n          return observableOf(res);\n        }\n        return this.http.request(method, url, { observe: 'response', headers: this.getHeaders() });\n      }),\n      map((res) => {\n        if (this.getOption(`${module}.alwaysFail`)) {\n          throw this.createFailResponse();\n        }\n\n        return res;\n      }),\n      map((res) => {\n        return new NbAuthResult(\n          true,\n          res,\n          this.getOption(`${module}.redirect.success`),\n          [],\n          this.getOption('messages.getter')(module, res, this.options),\n        );\n      }),\n      catchError((res) => {\n        return this.handleResponseError(res, module);\n      }),\n    );\n  }\n\n  refreshToken(data?: any): Observable<NbAuthResult> {\n    const module = 'refreshToken';\n    const method = this.getOption(`${module}.method`);\n    const url = this.getActionEndpoint(module);\n    const requireValidToken = this.getOption(`${module}.requireValidToken`);\n\n    return this.http.request(method, url, { body: data, observe: 'response', headers: this.getHeaders() }).pipe(\n      map((res) => {\n        if (this.getOption(`${module}.alwaysFail`)) {\n          throw this.createFailResponse(data);\n        }\n\n        return res;\n      }),\n      map((res) => {\n        return new NbAuthResult(\n          true,\n          res,\n          this.getOption(`${module}.redirect.success`),\n          [],\n          this.getOption('messages.getter')(module, res, this.options),\n          this.createToken(this.getOption('token.getter')(module, res, this.options), requireValidToken),\n        );\n      }),\n      catchError((res) => {\n        return this.handleResponseError(res, module);\n      }),\n    );\n  }\n\n  protected handleResponseError(res: any, module: string): Observable<NbAuthResult> {\n    let errors = [];\n    if (res instanceof HttpErrorResponse) {\n      errors = this.getOption('errors.getter')(module, res, this.options);\n    } else if (res instanceof NbAuthIllegalTokenError) {\n      errors.push(res.message);\n    } else {\n      errors.push('Something went wrong.');\n    }\n    return observableOf(new NbAuthResult(false, res, this.getOption(`${module}.redirect.failure`), errors));\n  }\n}\n"]}