perimeterx-js-core 0.5.1 → 0.6.0

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

@@ -0,0 +1,22 @@
+import { PXDE } from '../../pxde';
+import { IIncomingResponse } from '../../http';
+import { BlockAction } from '../../blocker';
+import { RiskStatus } from '../model';
+import { IRiskResponse } from './IRiskResponse';
+import { TokenVersion } from '../../risk_token';
+import { RiskResponsePayloadType } from './RiskResponsePayloadType';
+export declare abstract class RiskResponseBase<TokenV extends TokenVersion> implements IRiskResponse {
+    private readonly response;
+    protected riskResponse: RiskResponsePayloadType<TokenV>;
+    abstract score: number;
+    protected abstract validateRiskResponseScore(): boolean;
+    protected constructor(response: IIncomingResponse);
+    validate(): Promise<boolean>;
+    get status(): RiskStatus;
+    get action(): BlockAction;
+    get message(): string;
+    get pxhd(): string;
+    get uuid(): string;
+    get dataEnrichment(): PXDE;
+    get pxhdDomain(): string;
+}

package/lib/risk_api/risk_response/RiskResponseBase.js

@@ -0,0 +1,54 @@
+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 {
+    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;
+            }
+        });
+    }
+    get status() {
+        var _a;
+        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.status;
+    }
+    get action() {
+        var _a;
+        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.action;
+    }
+    get message() {
+        var _a;
+        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.message;
+    }
+    get pxhd() {
+        var _a;
+        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.pxhd;
+    }
+    get uuid() {
+        var _a;
+        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.uuid;
+    }
+    get dataEnrichment() {
+        var _a;
+        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.data_enrichment;
+    }
+    get pxhdDomain() {
+        var _a;
+        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.pxhdDomain;
+    }
+}

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

@@ -0,0 +1,4 @@
+import { TokenVersion } from '../../risk_token';
+import { RiskResponseV3Payload } from './v3';
+import { RiskResponseV2Payload } from './v2';
+export declare type RiskResponsePayloadType<TokenV extends TokenVersion> = TokenV extends TokenVersion.V3 ? RiskResponseV3Payload : TokenV extends TokenVersion.V2 ? RiskResponseV2Payload : never;

package/lib/risk_api/risk_response/RiskResponsePayloadType.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+export * from './IRiskResponse';
+export * from './RiskResponseBase';
+export * from './v2';
+export * from './v3';

package/lib/risk_api/risk_response/index.js

@@ -0,0 +1,4 @@
+export * from './IRiskResponse';
+export * from './RiskResponseBase';
+export * from './v2';
+export * from './v3';

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

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

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

@@ -0,0 +1,18 @@
+import { RiskResponseBase } from '../RiskResponseBase';
+export class DefaultRiskResponseV2 extends RiskResponseBase {
+    constructor(response) {
+        super(response);
+    }
+    get score() {
+        var _a, _b;
+        return typeof ((_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.cookie_cfg_block_result) === 'undefined'
+            ? undefined
+            : ((_b = this.riskResponse) === null || _b === void 0 ? void 0 : _b.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);
+    }
+}

package/lib/risk_api/{model/RiskResponseV2.d.ts → risk_response/v2/RiskResponseV2Payload.d.ts}

@@ -1,7 +1,7 @@
-import { RiskStatus } from './RiskStatus';
-import { PXDE } from '../../pxde';
-import { BlockAction } from '../../block_handler';
-export declare type RiskResponseV2 = {
+import { PXDE } from '../../../pxde';
+import { BlockAction } from '../../../blocker';
+import { RiskStatus } from '../../model';
+export declare type RiskResponseV2Payload = {
     status: RiskStatus;
     cookie_cfg_block_result?: '0' | '1';
     action?: BlockAction;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './DefaultRiskResponseV2';
+export * from './RiskResponseV2Payload';

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

@@ -0,0 +1,2 @@
+export * from './DefaultRiskResponseV2';
+export * from './RiskResponseV2Payload';

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

@@ -0,0 +1,8 @@
+import { IIncomingResponse } from '../../../http';
+import { TokenVersion } from '../../../risk_token';
+import { RiskResponseBase } from '../RiskResponseBase';
+export declare class DefaultRiskResponseV3 extends RiskResponseBase<TokenVersion.V3> {
+    constructor(response: IIncomingResponse);
+    get score(): number;
+    protected validateRiskResponseScore(): boolean;
+}

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

@@ -0,0 +1,14 @@
+import { RiskResponseBase } from '../RiskResponseBase';
+export class DefaultRiskResponseV3 extends RiskResponseBase {
+    constructor(response) {
+        super(response);
+    }
+    get score() {
+        var _a;
+        return (_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.score;
+    }
+    validateRiskResponseScore() {
+        var _a;
+        return typeof ((_a = this.riskResponse) === null || _a === void 0 ? void 0 : _a.score) === 'number';
+    }
+}

package/lib/risk_api/{model/RiskResponseV3.d.ts → risk_response/v3/RiskResponseV3Payload.d.ts}

@@ -1,7 +1,7 @@
-import { RiskStatus } from './RiskStatus';
-import { BlockAction } from '../../block_handler';
-import { PXDE } from '../../pxde';
-export declare type RiskResponseV3 = {
+import { BlockAction } from '../../../blocker';
+import { PXDE } from '../../../pxde';
+import { RiskStatus } from '../../model';
+export declare type RiskResponseV3Payload = {
     status: RiskStatus;
     score?: number;
     action?: BlockAction;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './DefaultRiskResponseV3';
+export * from './RiskResponseV3Payload';

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

@@ -0,0 +1,2 @@
+export * from './DefaultRiskResponseV3';
+export * from './RiskResponseV3Payload';

package/lib/risk_token/MobileError.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MobileError = void 0;
-var MobileError;
+export var MobileError;
 (function (MobileError) {
     MobileError["NO_COOKIE"] = "1";
     MobileError["CONNECTION_ERROR"] = "2";
     MobileError["CERTIFICATE_PINNING_ERROR"] = "3";
     MobileError["BYPASS"] = "4";
-})(MobileError = exports.MobileError || (exports.MobileError = {}));
+})(MobileError || (MobileError = {}));

package/lib/risk_token/TokenOrigin.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenOrigin = void 0;
-var TokenOrigin;
+export var TokenOrigin;
 (function (TokenOrigin) {
     TokenOrigin["COOKIE"] = "cookie";
     TokenOrigin["HEADER"] = "header";
-})(TokenOrigin = exports.TokenOrigin || (exports.TokenOrigin = {}));
+})(TokenOrigin || (TokenOrigin = {}));

package/lib/risk_token/{TokenVerificationResult.d.ts → TokenParseResult.d.ts}

@@ -1,5 +1,5 @@
-export declare enum TokenVerificationResult {
-    CANNOT_VERIFY = -1,
+export declare enum TokenParseResult {
+    NONE = -1,
     SUCCESSFUL = 0,
     DECRYPTION_FAILED = 1,
     VALIDATION_FAILED = 2

package/lib/risk_token/TokenParseResult.js

@@ -0,0 +1,7 @@
+export var TokenParseResult;
+(function (TokenParseResult) {
+    TokenParseResult[TokenParseResult["NONE"] = -1] = "NONE";
+    TokenParseResult[TokenParseResult["SUCCESSFUL"] = 0] = "SUCCESSFUL";
+    TokenParseResult[TokenParseResult["DECRYPTION_FAILED"] = 1] = "DECRYPTION_FAILED";
+    TokenParseResult[TokenParseResult["VALIDATION_FAILED"] = 2] = "VALIDATION_FAILED";
+})(TokenParseResult || (TokenParseResult = {}));

package/lib/risk_token/TokenVersion.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenVersion = void 0;
-var TokenVersion;
+export var TokenVersion;
 (function (TokenVersion) {
     TokenVersion["V2"] = "2";
     TokenVersion["V3"] = "3";
-})(TokenVersion = exports.TokenVersion || (exports.TokenVersion = {}));
+})(TokenVersion || (TokenVersion = {}));

package/lib/risk_token/constants.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COOKIE_V3_MAXIMUM_SALT_LENGTH = exports.COOKIE_V3_PARTS_COUNT = exports.COOKIE_V3_PAYLOAD_INDEX = exports.COOKIE_V3_ITERATIONS_INDEX = exports.COOKIE_V3_SALT_INDEX = exports.COOKIE_V3_HMAC_INDEX = exports.COOKIE_V3_NAME = exports.COOKIE_V2_NAME = exports.COOKIE_SPLIT_DELIMITER = void 0;
-exports.COOKIE_SPLIT_DELIMITER = ':';
-exports.COOKIE_V2_NAME = '_px2';
-exports.COOKIE_V3_NAME = '_px3';
-exports.COOKIE_V3_HMAC_INDEX = 0;
-exports.COOKIE_V3_SALT_INDEX = 1;
-exports.COOKIE_V3_ITERATIONS_INDEX = 2;
-exports.COOKIE_V3_PAYLOAD_INDEX = 3;
-exports.COOKIE_V3_PARTS_COUNT = 4;
-exports.COOKIE_V3_MAXIMUM_SALT_LENGTH = 100;
+export const COOKIE_SPLIT_DELIMITER = ':';
+export const COOKIE_V2_NAME = '_px2';
+export const COOKIE_V3_NAME = '_px3';
+export const COOKIE_V3_HMAC_INDEX = 0;
+export const COOKIE_V3_SALT_INDEX = 1;
+export const COOKIE_V3_ITERATIONS_INDEX = 2;
+export const COOKIE_V3_PAYLOAD_INDEX = 3;
+export const COOKIE_V3_PARTS_COUNT = 4;
+export const COOKIE_V3_MAXIMUM_SALT_LENGTH = 100;

package/lib/risk_token/index.d.ts

@@ -1,9 +1,8 @@
 export * from './constants';
 export * from './utils';
 export * from './token';
-export { RiskTokenScoreRetriever } from './RiskTokenScoreRetriever';
-export { MobileErrorHandler } from './MobileErrorHandler';
+export * from './parser';
 export { MobileError } from './MobileError';
 export { TokenOrigin } from './TokenOrigin';
-export { TokenVerificationResult } from './TokenVerificationResult';
+export { TokenParseResult } from './TokenParseResult';
 export { TokenVersion } from './TokenVersion';

package/lib/risk_token/index.js

@@ -1,32 +1,8 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenVersion = exports.TokenVerificationResult = exports.TokenOrigin = exports.MobileError = exports.MobileErrorHandler = exports.RiskTokenScoreRetriever = void 0;
-__exportStar(require("./constants"), exports);
-__exportStar(require("./utils"), exports);
-__exportStar(require("./token"), exports);
-var RiskTokenScoreRetriever_1 = require("./RiskTokenScoreRetriever");
-Object.defineProperty(exports, "RiskTokenScoreRetriever", { enumerable: true, get: function () { return RiskTokenScoreRetriever_1.RiskTokenScoreRetriever; } });
-var MobileErrorHandler_1 = require("./MobileErrorHandler");
-Object.defineProperty(exports, "MobileErrorHandler", { enumerable: true, get: function () { return MobileErrorHandler_1.MobileErrorHandler; } });
-var MobileError_1 = require("./MobileError");
-Object.defineProperty(exports, "MobileError", { enumerable: true, get: function () { return MobileError_1.MobileError; } });
-var TokenOrigin_1 = require("./TokenOrigin");
-Object.defineProperty(exports, "TokenOrigin", { enumerable: true, get: function () { return TokenOrigin_1.TokenOrigin; } });
-var TokenVerificationResult_1 = require("./TokenVerificationResult");
-Object.defineProperty(exports, "TokenVerificationResult", { enumerable: true, get: function () { return TokenVerificationResult_1.TokenVerificationResult; } });
-var TokenVersion_1 = require("./TokenVersion");
-Object.defineProperty(exports, "TokenVersion", { enumerable: true, get: function () { return TokenVersion_1.TokenVersion; } });
+export * from './constants';
+export * from './utils';
+export * from './token';
+export * from './parser';
+export { MobileError } from './MobileError';
+export { TokenOrigin } from './TokenOrigin';
+export { TokenParseResult } from './TokenParseResult';
+export { TokenVersion } from './TokenVersion';

package/lib/risk_token/parser/DefaultTokenV2Parser.d.ts

@@ -0,0 +1,13 @@
+import { IBase64Utils, IHmacUtils } from '../../utils';
+import { TokenParserBase } from './TokenParserBase';
+import { TokenVersion } from '../TokenVersion';
+import { IConfiguration } from '../../config';
+import { IToken } from '../token';
+export declare type DefaultTokenV2ParserOptions = {
+    base64Utils: IBase64Utils;
+    hmacUtils: IHmacUtils;
+};
+export declare class DefaultTokenV2Parser<Req, Res> extends TokenParserBase<TokenVersion.V2, Req, Res> {
+    constructor(config: IConfiguration<Req, Res>, options: DefaultTokenV2ParserOptions);
+    protected createToken(config: IConfiguration<Req, Res>, cookies: Record<string, string>, options: DefaultTokenV2ParserOptions): IToken<Req, Res>;
+}

package/lib/risk_token/parser/DefaultTokenV2Parser.js

@@ -0,0 +1,14 @@
+import { TokenParserBase } from './TokenParserBase';
+import { DefaultTokenV2 } from '../token';
+import { COOKIE_V2_NAME } from '../constants';
+export class DefaultTokenV2Parser extends TokenParserBase {
+    constructor(config, options) {
+        super(config, options);
+    }
+    createToken(config, cookies, options) {
+        if (cookies[COOKIE_V2_NAME]) {
+            return new DefaultTokenV2(config, cookies[COOKIE_V2_NAME], options.base64Utils, options.hmacUtils);
+        }
+        return null;
+    }
+}

package/lib/risk_token/parser/DefaultTokenV3Parser.d.ts

@@ -0,0 +1,13 @@
+import { IConfiguration } from '../../config';
+import { ICipherUtils, IHmacUtils } from '../../utils';
+import { TokenVersion } from '../TokenVersion';
+import { IToken } from '../token';
+import { TokenParserBase } from './TokenParserBase';
+export declare type DefaultTokenV3ParserOptions = {
+    cipherUtils: ICipherUtils;
+    hmacUtils: IHmacUtils;
+};
+export declare class DefaultTokenV3Parser<Req, Res> extends TokenParserBase<TokenVersion.V3, Req, Res> {
+    constructor(config: IConfiguration<Req, Res>, options: DefaultTokenV3ParserOptions);
+    protected createToken(config: IConfiguration<Req, Res>, cookies: Record<string, string>, options: DefaultTokenV3ParserOptions): IToken<Req, Res>;
+}

package/lib/risk_token/parser/DefaultTokenV3Parser.js

@@ -0,0 +1,14 @@
+import { DefaultTokenV3 } from '../token';
+import { COOKIE_V3_NAME } from '../constants';
+import { TokenParserBase } from './TokenParserBase';
+export class DefaultTokenV3Parser extends TokenParserBase {
+    constructor(config, options) {
+        super(config, options);
+    }
+    createToken(config, cookies, options) {
+        if (cookies[COOKIE_V3_NAME]) {
+            return new DefaultTokenV3(config, cookies[COOKIE_V3_NAME], options.cipherUtils, options.hmacUtils);
+        }
+        return null;
+    }
+}

package/lib/risk_token/parser/ITokenParser.d.ts

@@ -0,0 +1,4 @@
+import { ReadonlyContext, TokenData } from '../../context';
+export interface ITokenParser<Req, Res> {
+    parseToken(context: ReadonlyContext<Req, Res>): Promise<TokenData<Req, Res>>;
+}

package/lib/risk_token/parser/ITokenParser.js

@@ -0,0 +1 @@
+export {};

package/lib/risk_token/parser/TokenParserBase.d.ts

@@ -0,0 +1,19 @@
+import { DeepReadonly } from 'ts-essentials';
+import { IConfiguration } from '../../config';
+import { ReadonlyContext, RequestData, TokenData } from '../../context';
+import { IToken } from '../token';
+import { TokenVersion } from '../TokenVersion';
+import { ITokenParser } from './ITokenParser';
+import { TokenOptionsType } from './TokenParserOptions';
+export declare abstract class TokenParserBase<Version extends TokenVersion, Req, Res> implements ITokenParser<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly options: TokenOptionsType<Version>;
+    protected constructor(config: IConfiguration<Req, Res>, options: TokenOptionsType<Version>);
+    protected abstract createToken(config: IConfiguration<Req, Res>, cookies: Record<string, string>, options: TokenOptionsType<Version>): IToken<Req, Res>;
+    parseToken(context: ReadonlyContext<Req, Res>): Promise<TokenData<Req, Res>>;
+    protected initializeToken({ requestData, isMobile }: ReadonlyContext<Req, Res>): TokenData<Req, Res>;
+    protected createMobileTokenData({ request }: DeepReadonly<RequestData<Req>>): TokenData<Req, Res>;
+    protected getMobileToken(mobileToken: string): IToken<Req, Res>;
+    protected createWebTokenData(cookies: Record<string, string>): TokenData<Req, Res>;
+    private handleMobileErrorIfNeeded;
+}

package/lib/risk_token/parser/TokenParserBase.js

@@ -0,0 +1,94 @@
+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 {
+    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;
+            }
+            return tokenData;
+        });
+    }
+    initializeToken({ requestData, isMobile }) {
+        if (isMobile) {
+            return this.createMobileTokenData(requestData);
+        }
+        else {
+            return this.createWebTokenData(requestData.cookies);
+        }
+    }
+    createMobileTokenData({ request }) {
+        const mobileToken = request.headers.get(X_PX_AUTHORIZATION_HEADER_NAME);
+        const tokenData = {
+            tokenParseResult: TokenParseResult.NONE,
+            token: this.getMobileToken(mobileToken),
+            mobileData: {
+                originalToken: this.getMobileToken(request.headers.get(X_PX_ORIGINAL_TOKEN_HEADER_NAME)),
+                bypassReason: request.headers.get(X_PX_BYPASS_REASON_HEADER_NAME) || '',
+            },
+        };
+        if (!tokenData.token && /^\d+$/.test(mobileToken)) {
+            tokenData.mobileData.mobileError = mobileToken;
+        }
+        return tokenData;
+    }
+    getMobileToken(mobileToken) {
+        try {
+            if (!mobileToken || (mobileToken === null || mobileToken === void 0 ? void 0 : mobileToken.indexOf(COOKIE_SPLIT_DELIMITER)) === -1) {
+                return null;
+            }
+            const [tokenVersion, ...cookieString] = mobileToken.split(COOKIE_SPLIT_DELIMITER);
+            const cookieName = convertMobileTokenVersionToCookieName(tokenVersion);
+            if (!cookieName) {
+                return null;
+            }
+            return this.createToken(this.config, { [cookieName]: cookieString.join(COOKIE_SPLIT_DELIMITER) }, this.options);
+        }
+        catch (e) {
+            this.config.logger.debug(`error extracting mobile token - ${e}, token: ${mobileToken}`);
+            return null;
+        }
+    }
+    createWebTokenData(cookies) {
+        return {
+            tokenParseResult: TokenParseResult.NONE,
+            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();
+            }
+        });
+    }
+}

package/lib/risk_token/parser/TokenParserOptions.d.ts

@@ -0,0 +1,4 @@
+import { TokenVersion } from '../TokenVersion';
+import { DefaultTokenV3ParserOptions } from './DefaultTokenV3Parser';
+import { DefaultTokenV2ParserOptions } from './DefaultTokenV2Parser';
+export declare type TokenOptionsType<TokenV> = TokenV extends TokenVersion.V2 ? DefaultTokenV2ParserOptions : DefaultTokenV3ParserOptions;

package/lib/risk_token/parser/TokenParserOptions.js

@@ -0,0 +1 @@
+export {};

package/lib/risk_token/parser/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ITokenParser';
+export * from './TokenParserBase';
+export * from './TokenParserOptions';
+export * from './DefaultTokenV2Parser';
+export * from './DefaultTokenV3Parser';

package/lib/risk_token/parser/index.js

@@ -0,0 +1,5 @@
+export * from './ITokenParser';
+export * from './TokenParserBase';
+export * from './TokenParserOptions';
+export * from './DefaultTokenV2Parser';
+export * from './DefaultTokenV3Parser';

package/lib/risk_token/token/{IBotDefenderToken.d.ts → IToken.d.ts}

@@ -1,7 +1,8 @@
-import { BlockAction } from '../../block_handler';
-import { IContext } from '../../context';
-import { TokenVerificationResult } from '../TokenVerificationResult';
-export interface IBotDefenderToken {
+import { AsyncOrSync } from 'ts-essentials';
+import { BlockAction } from '../../blocker';
+import { ReadonlyContext } from '../../context';
+import { TokenParseResult } from '../TokenParseResult';
+export interface IToken<Req, Res> {
     /**
      * The HMAC string on the cookie.
      */
@@ -28,9 +29,9 @@ export interface IBotDefenderToken {
     readonly score: number;
     /**
      * @param context - The request context.
-     * @returns Promise<boolean> - Whether or not the cookie was successfully decrypted and validated.
+     * @returns Promise<boolean> - Whether the cookie was successfully decrypted and validated.
      */
-    verify(context: IContext): Promise<TokenVerificationResult>;
+    verify(context: ReadonlyContext<Req, Res>): AsyncOrSync<TokenParseResult>;
     /**
      * @returns boolean - Whether the cookie's timestamp is expired.
      */
@@ -44,11 +45,11 @@ export interface IBotDefenderToken {
      */
     isValid(): boolean;
     /**
-     * @returns string - The encrypted cookie string as received on the request.
+     * @returns string - The encrypted token string as received on the request.
      */
-    getCookieString(): string;
+    getTokenString(): string;
     /**
-     * @returns string - The decrypted cookie payload as a JSON string.
+     * @returns string - The decrypted token payload as a JSON string.
      */
     getPayloadString(): string;
 }

package/lib/risk_token/token/IToken.js

@@ -0,0 +1 @@
+export {};

package/lib/risk_token/token/TokenBase.d.ts

@@ -0,0 +1,32 @@
+import { AsyncOrSync } from 'ts-essentials';
+import { IToken } from './IToken';
+import { TokenParseResult } from '../TokenParseResult';
+import { ReadonlyContext } from '../../context';
+import { BlockAction } from '../../blocker';
+import { IConfiguration } from '../../config';
+import { ILogger } from '../../logger';
+import { TokenPayloadType } from './TokenPayloadType';
+import { TokenVersion } from '../TokenVersion';
+export declare abstract class TokenBase<TokenV extends TokenVersion, Req, Res> implements IToken<Req, Res> {
+    abstract readonly action: BlockAction;
+    abstract readonly hmac: string;
+    abstract readonly score: number;
+    abstract readonly timestamp: number;
+    abstract readonly uuid: string;
+    abstract readonly vid: string;
+    abstract isExpired(): boolean;
+    abstract isHighScore(): boolean;
+    protected abstract decrypt(context: ReadonlyContext<Req, Res>): AsyncOrSync<TokenPayloadType<TokenV>>;
+    protected abstract validate(context: ReadonlyContext<Req, Res>): AsyncOrSync<boolean>;
+    protected readonly logger: ILogger;
+    protected payload: TokenPayloadType<TokenV>;
+    protected cookieString: string;
+    protected cookieSecret: string;
+    protected cookieMaxLength: number;
+    protected isValidated: boolean;
+    protected constructor(config: IConfiguration<Req, Res>, cookieString: string);
+    verify(context: ReadonlyContext<Req, Res>): Promise<TokenParseResult>;
+    isValid(): boolean;
+    getTokenString(): string;
+    getPayloadString(): string;
+}