perimeterx-js-core 0.7.0 → 0.8.0

package/lib/risk_api/client/PostRiskApiClientBase.js

@@ -1,19 +1,11 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { ProductName } from '../../products';
 import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../../http';
-import { EnforcerErrorName, getAuthorizationHeader, ModuleMode, removeSensitiveHeaders, transferExistingProperties, } from '../../utils';
+import { EnforcerErrorName, getAuthorizationHeader, removeSensitiveHeaders, } from '../../utils';
+import { createCommonActivityDetails, toHeaderEntryArray } from '../../activities';
 import { RISK_API_ENDPOINT } from '../constants';
 import { RiskApiCallResult, RiskStatus, S2SErrorReason } from '../model';
-import { TokenParseResult } from '../../risk_token';
 export class PostRiskApiClientBase {
+    config;
+    httpClient;
     constructor(config, httpClient) {
         this.config = config;
         this.httpClient = httpClient;
@@ -23,32 +15,30 @@ export class PostRiskApiClientBase {
      * @param context
      * @returns Promise<RiskApiData>
      */
-    executeRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let response, riskResponse;
-            const riskApiData = { riskApiCallResult: RiskApiCallResult.NONE };
-            try {
-                const riskActivity = this.createRiskActivity(context);
-                response = yield this.sendRiskActivity(riskActivity, riskApiData);
-                if ((response === null || response === void 0 ? void 0 : response.status) !== 200) {
-                    return yield this.handleS2SError(riskApiData, response);
-                }
-                riskResponse = this.createRiskResponse(response);
-                riskApiData.riskResponse = riskResponse;
-                if (!(yield riskResponse.validate())) {
-                    return yield this.handleS2SError(riskApiData, response);
-                }
-                this.config.logger.debug(`received risk response, score: ${riskResponse.score}, rtt: ${riskApiData.riskRtt}`);
-                return riskApiData;
+    async executeRiskApi(context) {
+        let response, riskResponse;
+        const riskApiData = { riskApiCallResult: RiskApiCallResult.NONE };
+        try {
+            const riskActivity = this.createRiskActivity(context);
+            response = await this.sendRiskActivity(riskActivity, riskApiData);
+            if (response?.status !== 200) {
+                return await this.handleS2SError(riskApiData, response);
             }
-            catch (err) {
-                if (err.name === EnforcerErrorName.ENFORCER_TIMEOUT_ERROR) {
-                    return this.handleS2STimeout(riskApiData);
-                }
-                this.config.logger.error(`caught error in risk api: ${err} - ${JSON.stringify(context.requestData.url)}`);
-                return yield this.handleS2SError(riskApiData, response, err);
+            riskResponse = this.createRiskResponse(response);
+            riskApiData.riskResponse = riskResponse;
+            if (!(await riskResponse.validate())) {
+                return await this.handleS2SError(riskApiData, response);
             }
-        });
+            this.config.logger.debug(`received risk response, score: ${riskResponse.score}, rtt: ${riskApiData.riskRtt}`);
+            return riskApiData;
+        }
+        catch (err) {
+            if (err.name === EnforcerErrorName.ENFORCER_TIMEOUT_ERROR) {
+                return this.handleS2STimeout(riskApiData);
+            }
+            this.config.logger.error(`caught error in risk api: ${err} - ${JSON.stringify(context.requestData.url)}`);
+            return await this.handleS2SError(riskApiData, response, err);
+        }
     }
     /**
      * Creates the RiskActivity payload
@@ -57,26 +47,20 @@ export class PostRiskApiClientBase {
      * @protected
      */
     createRiskActivity(context) {
-        var _a, _b, _c;
         const riskActivity = {
+            vid: context.vid,
+            client_uuid: context.uuid,
+            pxhd: context.pxhd?.value,
             request: {
-                ip: context.requestData.ip,
+                socket_ip: context.requestData.ip,
                 headers: this.formatRiskHeadersField(context.requestData.headers),
                 url: context.requestData.rawUrl,
             },
             additional: {
-                s2s_call_reason: ((_a = context.reasons) === null || _a === void 0 ? void 0 : _a[ProductName.BOT_DEFENDER]) ||
-                    ((_b = context.reasons) === null || _b === void 0 ? void 0 : _b[ProductName.CREDENTIAL_INTELLIGENCE]),
-                module_version: this.config.moduleVersion,
-                http_method: context.requestData.method,
-                http_version: context.requestData.httpVersion,
-                risk_mode: ((_c = context.productData.bd) === null || _c === void 0 ? void 0 : _c.isMonitoredRequest) ? ModuleMode.MONITOR : ModuleMode.ACTIVE_BLOCKING,
-                cookie_origin: context.tokenOrigin,
-                request_cookie_names: context.requestData.requestCookieNames.concat(),
-                request_id: context.requestId,
+                ...createCommonActivityDetails(this.config, context),
+                s2s_call_reason: context.riskApiData.s2sCallReason,
             },
         };
-        this.addOptionalRiskFields(riskActivity, context);
         return this.finalizeRiskActivity(riskActivity);
     }
     /**
@@ -88,105 +72,23 @@ export class PostRiskApiClientBase {
     finalizeRiskActivity(riskActivity) {
         return riskActivity;
     }
-    addOptionalRiskFields(riskActivity, context) {
-        this.addOptionalRiskFieldsToRoot(riskActivity, context);
-        this.addOptionalRiskFieldsToAdditional(riskActivity, context);
-        this.addProductDataToAdditional(riskActivity, context.productData);
-        this.addTokenDataToAdditional(riskActivity, context.tokenData);
-        this.addCustomParamsToAdditional(riskActivity, context);
-    }
-    addOptionalRiskFieldsToRoot(riskActivity, context) {
-        var _a;
-        transferExistingProperties(context, riskActivity, {
-            vid: 'vid',
-            uuid: 'uuid',
-        });
-        if ((_a = context.pxhd) === null || _a === void 0 ? void 0 : _a.value) {
-            riskActivity.pxhd = context.pxhd.value;
-        }
-    }
-    addOptionalRiskFieldsToAdditional(riskActivity, context) {
-        transferExistingProperties(context, riskActivity.additional, {
-            vidSource: 'enforcer_vid_source',
-            graphqlData: 'graphql_operations',
-        });
-        transferExistingProperties(context.serverData, riskActivity.additional, {
-            region: 'server_info_region',
-            datacenter: 'server_info_datacenter',
-        });
-        transferExistingProperties(context.tlsData, riskActivity.additional, {
-            tlsProtocol: 'tls_protocol',
-            tlsServer: 'tls_server',
-            tlsCipher: 'tls_cipher',
-            tlsCiphersSha: 'tls_ciphers_sha',
-            tlsExtensionSha: 'tls_extension_sha',
-            tlsPreferredCiphers: 'tls_preferred_ciphers',
-            tlsJa3Fingerprint: 'tls_ja3_fingerprint',
-        });
-    }
-    addProductDataToAdditional(riskActivity, productData) {
-        transferExistingProperties(productData.ad, riskActivity.additional, {
-            appUserId: 'app_user_id',
-            additionalFields: 'jwt_additional_fields',
-            crossTabSession: 'cross_tab_session',
-        });
-        transferExistingProperties(productData.ci, riskActivity.additional, {
-            hashedUsername: 'user',
-            hashedPassword: 'pass',
-            ciVersion: 'ci_version',
-            ssoStep: 'sso_step',
-        });
-    }
-    addCustomParamsToAdditional(riskActivity, context) {
-        if (context.customParameters) {
-            Object.assign(riskActivity.additional, context.customParameters);
-        }
-    }
-    addTokenDataToAdditional(riskActivity, { token, mobileData }) {
-        if (token) {
-            if (token.isValid()) {
-                riskActivity.additional.px_cookie = token.getPayloadString();
-                riskActivity.additional.px_cookie_hmac = token.hmac;
-            }
-            else {
-                riskActivity.additional.px_orig_cookie = token.getTokenString();
-            }
-        }
-        if (mobileData) {
-            transferExistingProperties(mobileData, riskActivity.additional, {
-                originalToken: 'original_token',
-                decodedOriginalToken: 'px_decoded_original_token',
-            });
-            if (mobileData.originalTokenParseResult === TokenParseResult.DECRYPTION_FAILED) {
-                riskActivity.additional.original_token_error = 'cookie_decryption_failed';
-            }
-            else if (mobileData.originalTokenParseResult === TokenParseResult.VALIDATION_FAILED) {
-                riskActivity.additional.original_token_error = 'cookie_validation_failed';
-            }
-        }
-    }
     formatRiskHeadersField(headers) {
         const headersWithoutSensitive = removeSensitiveHeaders(headers, this.config.sensitiveHeaders);
-        return Object.entries(headersWithoutSensitive).flatMap(([key, values]) => values.map((value) => ({
-            name: key,
-            value: value,
-        })));
-    }
-    sendRiskActivity(riskActivity, riskApiData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const url = this.getRiskUrl();
-            const headers = this.getRiskHeaders();
-            const body = JSON.stringify(riskActivity);
-            const method = HttpMethod.POST;
-            const riskRequest = new OutgoingRequestImpl({ url, method, headers, body });
-            this.config.logger.debug(`sending risk api to ${url}`);
-            const startTime = Date.now();
-            const response = yield this.httpClient.send(riskRequest, { timeoutMs: this.config.s2sTimeout });
-            const endTime = Date.now();
-            riskApiData.riskApiCallResult = RiskApiCallResult.SUCCESSFUL;
-            riskApiData.riskRtt = endTime - startTime;
-            return response;
-        });
+        return toHeaderEntryArray(headersWithoutSensitive);
+    }
+    async sendRiskActivity(riskActivity, riskApiData) {
+        const url = this.getRiskUrl();
+        const headers = this.getRiskHeaders();
+        const body = JSON.stringify(riskActivity);
+        const method = HttpMethod.POST;
+        const riskRequest = new OutgoingRequestImpl({ url, method, headers, body });
+        this.config.logger.debug(`sending risk api to ${url}`);
+        const startTime = Date.now();
+        const response = await this.httpClient.send(riskRequest, { timeoutMs: this.config.s2sTimeout });
+        const endTime = Date.now();
+        riskApiData.riskApiCallResult = RiskApiCallResult.SUCCESSFUL;
+        riskApiData.riskRtt = endTime - startTime;
+        return response;
     }
     getRiskUrl() {
         return `${this.config.backendScoreApiUrl}${RISK_API_ENDPOINT}`;
@@ -201,35 +103,32 @@ export class PostRiskApiClientBase {
         riskApiData.riskApiCallResult = RiskApiCallResult.TIMEOUT;
         return riskApiData;
     }
-    handleS2SError(riskApiData, response, error) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            riskApiData.riskApiCallResult = RiskApiCallResult.ERROR;
-            riskApiData.errorReason = S2SErrorReason.UNKNOWN_ERROR;
-            if (response || riskApiData.riskResponse) {
-                riskApiData.errorHttpStatus = response.status;
-                riskApiData.errorMessage = ((_a = riskApiData.riskResponse) === null || _a === void 0 ? void 0 : _a.message) || `response body: ${yield response.text()}`;
-                if (response.status === 200) {
-                    if (((_b = riskApiData.riskResponse) === null || _b === void 0 ? void 0 : _b.status) === RiskStatus.FAILURE) {
-                        riskApiData.errorReason = S2SErrorReason.REQUEST_FAILED_ON_SERVER;
-                    }
-                    else if (!(yield ((_c = riskApiData.riskResponse) === null || _c === void 0 ? void 0 : _c.validate()))) {
-                        riskApiData.errorReason = S2SErrorReason.INVALID_RESPONSE;
-                    }
-                }
-                else if (response.status >= 400 && response.status < 500) {
-                    riskApiData.errorReason = S2SErrorReason.BAD_REQUEST;
+    async handleS2SError(riskApiData, response, error) {
+        riskApiData.riskApiCallResult = RiskApiCallResult.ERROR;
+        riskApiData.errorReason = S2SErrorReason.UNKNOWN_ERROR;
+        if (response || riskApiData.riskResponse) {
+            riskApiData.errorHttpStatus = response.status;
+            riskApiData.errorMessage = riskApiData.riskResponse?.message || `response body: ${await response.text()}`;
+            if (response.status === 200) {
+                if (riskApiData.riskResponse?.status === RiskStatus.FAILURE) {
+                    riskApiData.errorReason = S2SErrorReason.REQUEST_FAILED_ON_SERVER;
                 }
-                else if (response.status >= 500 && response.status < 600) {
-                    riskApiData.errorReason = S2SErrorReason.SERVER_ERROR;
+                else if (!(await riskApiData.riskResponse?.validate())) {
+                    riskApiData.errorReason = S2SErrorReason.INVALID_RESPONSE;
                 }
             }
-            if (error) {
-                const errorMessage = `${error}`;
-                const existingMessage = riskApiData.errorMessage;
-                riskApiData.errorMessage = existingMessage ? `${existingMessage}, ${errorMessage}` : errorMessage;
+            else if (response.status >= 400 && response.status < 500) {
+                riskApiData.errorReason = S2SErrorReason.BAD_REQUEST;
             }
-            return riskApiData;
-        });
+            else if (response.status >= 500 && response.status < 600) {
+                riskApiData.errorReason = S2SErrorReason.SERVER_ERROR;
+            }
+        }
+        if (error) {
+            const errorMessage = `${error}`;
+            const existingMessage = riskApiData.errorMessage;
+            riskApiData.errorMessage = existingMessage ? `${existingMessage}, ${errorMessage}` : errorMessage;
+        }
+        return riskApiData;
     }
 }

package/lib/risk_api/model/RiskActivity.d.ts

@@ -1,56 +1,16 @@
-import { ModuleMode, VidSource } from '../../utils';
-import { TokenOrigin } from '../../risk_token';
-import { CustomParameters } from '../../custom_parameters';
-import { GraphQLData } from '../../graphql/';
-import { CredentialIntelligenceVersion, SsoStep } from '../../products';
-export type HeaderEntry = {
-    name: string;
-    value: string;
-};
+import { HeaderEntry, CommonActivityDetails } from '../../activities';
 export type RiskRequestData = {
-    ip: string;
+    socket_ip: string;
     url: string;
     headers: HeaderEntry[];
 };
 export type RiskAdditionalData = {
-    request_id: string;
-    module_version: string;
     s2s_call_reason: string;
-    risk_mode: ModuleMode;
-    http_method: string;
-    http_version?: string;
-    px_orig_cookie?: string;
-    px_cookie?: string;
-    px_cookie_hmac?: string;
-    tls_protocol?: string;
-    tls_server?: string;
-    tls_cipher?: string;
-    tls_ciphers_sha?: string;
-    tls_extension_sha?: string;
-    tls_preferred_ciphers?: string;
-    tls_ja3_fingerprint?: string;
-    enforcer_vid_source?: VidSource;
-    original_uuid?: string;
-    original_token_error?: string;
-    original_token?: string;
-    px_decoded_original_token?: string;
-    cookie_origin?: TokenOrigin;
-    request_cookie_names?: string[];
-    server_info_region?: string;
-    server_info_datacenter?: string;
-    cross_tab_session?: string;
-    app_user_id?: string;
-    jwt_additional_fields?: Record<string, any>;
-    graphql_operations?: GraphQLData[];
-    user?: string;
-    pass?: string;
-    ci_version?: CredentialIntelligenceVersion;
-    sso_step?: SsoStep;
-} & CustomParameters;
+};
 export type RiskActivity = {
     vid?: string;
-    uuid?: string;
+    client_uuid?: string;
     pxhd?: string;
     request: RiskRequestData;
-    additional: RiskAdditionalData;
+    additional: RiskAdditionalData & CommonActivityDetails;
 };

package/lib/risk_api/risk_response/IRiskResponse.d.ts

@@ -11,5 +11,6 @@ export interface IRiskResponse {
     readonly pxhdDomain?: string;
     readonly message?: string;
     readonly dataEnrichment?: PXDE;
+    readonly additionalRiskInfo?: string;
     validate(): AsyncOrSync<boolean>;
 }

package/lib/risk_api/risk_response/RiskResponseBase.d.ts

@@ -19,4 +19,5 @@ export declare abstract class RiskResponseBase<TokenV extends TokenVersion> impl
     get uuid(): string;
     get dataEnrichment(): PXDE;
     get pxhdDomain(): string;
+    get additionalRiskInfo(): string;
 }

package/lib/risk_api/risk_response/RiskResponseBase.js

@@ -1,54 +1,41 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { RiskStatus } from '../model';
 export class RiskResponseBase {
+    response;
+    riskResponse;
     constructor(response) {
         this.response = response;
     }
-    validate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.riskResponse = (yield this.response.json());
-                return this.status === RiskStatus.SUCCESS && this.validateRiskResponseScore();
-            }
-            catch (e) {
-                return false;
-            }
-        });
+    async validate() {
+        try {
+            this.riskResponse = (await this.response.json());
+            return this.status === RiskStatus.SUCCESS && this.validateRiskResponseScore();
+        }
+        catch (e) {
+            return false;
+        }
     }
     get status() {
-        var _a;
-        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.status;
+        return this.riskResponse?.status;
     }
     get action() {
-        var _a;
-        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.action;
+        return this.riskResponse?.action;
     }
     get message() {
-        var _a;
-        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.message;
+        return this.riskResponse?.message;
     }
     get pxhd() {
-        var _a;
-        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.pxhd;
+        return this.riskResponse?.pxhd;
     }
     get uuid() {
-        var _a;
-        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.uuid;
+        return this.riskResponse?.uuid;
     }
     get dataEnrichment() {
-        var _a;
-        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.data_enrichment;
+        return this.riskResponse?.data_enrichment;
     }
     get pxhdDomain() {
-        var _a;
-        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.pxhdDomain;
+        return this.riskResponse?.pxhdDomain;
+    }
+    get additionalRiskInfo() {
+        return this.riskResponse?.additional_risk_info;
     }
 }

package/lib/risk_api/risk_response/v2/DefaultRiskResponseV2.d.ts

@@ -1,6 +1,6 @@
 import { IIncomingResponse } from '../../../http';
-import { RiskResponseBase } from '../RiskResponseBase';
 import { TokenVersion } from '../../../risk_token';
+import { RiskResponseBase } from '../RiskResponseBase';
 export declare class DefaultRiskResponseV2 extends RiskResponseBase<TokenVersion.V2> {
     constructor(response: IIncomingResponse);
     get score(): number;

package/lib/risk_api/risk_response/v2/DefaultRiskResponseV2.js

@@ -4,15 +4,13 @@ export class DefaultRiskResponseV2 extends RiskResponseBase {
         super(response);
     }
     get score() {
-        var _a, _b;
-        return typeof ((_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.cookie_cfg_block_result) === 'undefined'
+        return typeof this.riskResponse?.cookie_cfg_block_result === 'undefined'
             ? undefined
-            : ((_b = this.riskResponse) === null || _b === void 0 ? void 0 : _b.cookie_cfg_block_result) === '1'
+            : this.riskResponse?.cookie_cfg_block_result === '1'
                 ? 100
                 : 0;
     }
     validateRiskResponseScore() {
-        var _a;
-        return ['0', '1'].includes((_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.cookie_cfg_block_result);
+        return ['0', '1'].includes(this.riskResponse?.cookie_cfg_block_result);
     }
 }

package/lib/risk_api/risk_response/v2/RiskResponseV2Payload.d.ts

@@ -10,4 +10,5 @@ export type RiskResponseV2Payload = {
     pxhdDomain?: string;
     message?: string;
     data_enrichment?: PXDE;
+    additional_risk_info?: string;
 };

package/lib/risk_api/risk_response/v3/DefaultRiskResponseV3.js

@@ -4,11 +4,9 @@ export class DefaultRiskResponseV3 extends RiskResponseBase {
         super(response);
     }
     get score() {
-        var _a;
-        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.score;
+        return this.riskResponse?.score;
     }
     validateRiskResponseScore() {
-        var _a;
-        return typeof ((_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.score) === 'number';
+        return typeof this.riskResponse?.score === 'number';
     }
 }

package/lib/risk_api/risk_response/v3/RiskResponseV3Payload.d.ts

@@ -10,4 +10,5 @@ export type RiskResponseV3Payload = {
     pxhdDomain?: string;
     message?: string;
     data_enrichment?: PXDE;
+    additional_risk_info?: string;
 };

package/lib/risk_token/parser/TokenParserBase.js

@@ -1,38 +1,29 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { X_PX_AUTHORIZATION_HEADER_NAME, X_PX_BYPASS_REASON_HEADER_NAME, X_PX_ORIGINAL_TOKEN_HEADER_NAME, } from '../../utils';
 import { TokenParseResult } from '../TokenParseResult';
 import { COOKIE_SPLIT_DELIMITER } from '../constants';
 import { convertMobileTokenVersionToCookieName } from '../utils';
 export class TokenParserBase {
+    config;
+    options;
     constructor(config, options) {
         this.config = config;
         this.options = options;
     }
-    parseToken(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tokenData = this.initializeToken(context);
-            try {
-                if (!tokenData.token) {
-                    this.config.logger.debug('no token found');
-                    yield this.handleMobileErrorIfNeeded(context, tokenData);
-                    return tokenData;
-                }
-                tokenData.tokenParseResult = yield tokenData.token.verify(context);
-            }
-            catch (e) {
-                this.config.logger.debug(`could not parse token - ${e}`);
-                tokenData.tokenParseResult = tokenData.token ? TokenParseResult.DECRYPTION_FAILED : TokenParseResult.NONE;
+    async parseToken(context) {
+        const tokenData = this.initializeToken(context);
+        try {
+            if (!tokenData.token) {
+                this.config.logger.debug('no token found');
+                await this.handleMobileErrorIfNeeded(context, tokenData);
+                return tokenData;
             }
-            return tokenData;
-        });
+            tokenData.tokenParseResult = await tokenData.token.verify(context);
+        }
+        catch (e) {
+            this.config.logger.debug(`could not parse token - ${e}`);
+            tokenData.tokenParseResult = tokenData.token ? TokenParseResult.DECRYPTION_FAILED : TokenParseResult.NONE;
+        }
+        return tokenData;
     }
     initializeToken({ requestData, isMobile }) {
         if (isMobile) {
@@ -59,7 +50,7 @@ export class TokenParserBase {
     }
     getMobileToken(mobileToken) {
         try {
-            if (!mobileToken || (mobileToken === null || mobileToken === void 0 ? void 0 : mobileToken.indexOf(COOKIE_SPLIT_DELIMITER)) === -1) {
+            if (!mobileToken || mobileToken?.indexOf(COOKIE_SPLIT_DELIMITER) === -1) {
                 return null;
             }
             const [tokenVersion, ...cookieString] = mobileToken.split(COOKIE_SPLIT_DELIMITER);
@@ -80,15 +71,13 @@ export class TokenParserBase {
             token: this.createToken(this.config, cookies, this.options),
         };
     }
-    handleMobileErrorIfNeeded(context, { mobileData }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!mobileData || !mobileData.mobileError || !mobileData.originalToken) {
-                return;
-            }
-            mobileData.originalTokenParseResult = yield mobileData.originalToken.verify(context);
-            if (mobileData.originalTokenParseResult === TokenParseResult.SUCCESSFUL) {
-                mobileData.decodedOriginalToken = mobileData.originalToken.getPayloadString();
-            }
-        });
+    async handleMobileErrorIfNeeded(context, { mobileData }) {
+        if (!mobileData || !mobileData.mobileError || !mobileData.originalToken) {
+            return;
+        }
+        mobileData.originalTokenParseResult = await mobileData.originalToken.verify(context);
+        if (mobileData.originalTokenParseResult === TokenParseResult.SUCCESSFUL) {
+            mobileData.decodedOriginalToken = mobileData.originalToken.getPayloadString();
+        }
     }
 }

package/lib/risk_token/token/TokenBase.js

@@ -1,14 +1,11 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { TokenParseResult } from '../TokenParseResult';
 export class TokenBase {
+    logger;
+    payload;
+    cookieString;
+    cookieSecret;
+    cookieMaxLength;
+    isValidated;
     constructor(config, cookieString) {
         this.logger = config.logger;
         this.cookieSecret = config.cookieSecret;
@@ -16,27 +13,25 @@ export class TokenBase {
         this.cookieString = cookieString;
         this.isValidated = false;
     }
-    verify(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cookieString) {
-                return TokenParseResult.NONE;
-            }
-            if (this.isValid()) {
-                return TokenParseResult.SUCCESSFUL;
-            }
-            if (this.cookieString.length > this.cookieMaxLength) {
-                return TokenParseResult.DECRYPTION_FAILED;
-            }
-            this.payload = this.payload || (yield this.decrypt(context));
-            if (!this.payload) {
-                return TokenParseResult.DECRYPTION_FAILED;
-            }
-            if (!(yield this.validate(context))) {
-                return TokenParseResult.VALIDATION_FAILED;
-            }
-            this.isValidated = true;
+    async verify(context) {
+        if (!this.cookieString) {
+            return TokenParseResult.NONE;
+        }
+        if (this.isValid()) {
             return TokenParseResult.SUCCESSFUL;
-        });
+        }
+        if (this.cookieString.length > this.cookieMaxLength) {
+            return TokenParseResult.DECRYPTION_FAILED;
+        }
+        this.payload = this.payload || (await this.decrypt(context));
+        if (!this.payload) {
+            return TokenParseResult.DECRYPTION_FAILED;
+        }
+        if (!(await this.validate(context))) {
+            return TokenParseResult.VALIDATION_FAILED;
+        }
+        this.isValidated = true;
+        return TokenParseResult.SUCCESSFUL;
     }
     isValid() {
         return this.isValidated;