perimeterx-js-core 0.1.1 → 0.2.0

package/lib/activities/HttpActivityClient.d.ts

@@ -2,11 +2,19 @@ import { IConfiguration } from '../config';
 import { IContext } from '../context';
 import { IHttpClient } from '../http';
 import { IActivityClient } from './IActivityClient';
+import { Activity } from './model/Activity';
 export declare class HttpActivityClient implements IActivityClient {
     private readonly config;
     private readonly httpClient;
     constructor(config: IConfiguration, httpClient: IHttpClient);
     sendActivities(context: IContext): Promise<boolean>;
-    private createActivities;
-    private postActivities;
+    protected createActivities(context: IContext): Activity[];
+    /**
+     * Allows for expansions or alterations to the async activity if needed.
+     * @param activity
+     * @returns Activity
+     * @protected
+     */
+    protected finalizeActivity(activity: Activity): Activity;
+    protected postActivities(activities: Activity[]): Promise<boolean>;
 }

package/lib/activities/HttpActivityClient.js

@@ -74,7 +74,16 @@ var HttpActivityClient = /** @class */ (function () {
         else if (context.passReason) {
             activities.push((0, utils_2.createActivity)(ActivityType_1.ActivityType.PAGE_REQUESTED, this.config, context));
         }
-        return activities;
+        return activities.map(this.finalizeActivity);
+    };
+    /**
+     * Allows for expansions or alterations to the async activity if needed.
+     * @param activity
+     * @returns Activity
+     * @protected
+     */
+    HttpActivityClient.prototype.finalizeActivity = function (activity) {
+        return activity;
     };
     HttpActivityClient.prototype.postActivities = function (activities) {
         return __awaiter(this, void 0, void 0, function () {

package/lib/activities/HttpBatchedActivityClient.d.ts

@@ -0,0 +1,21 @@
+import { HttpActivityClient } from './HttpActivityClient';
+import { IConfiguration } from '../config';
+import { IHttpClient } from '../http';
+import { Activity } from './model/Activity';
+export declare class HttpBatchedActivityClient extends HttpActivityClient {
+    private readonly batchSize;
+    private readonly timeoutMs;
+    private readonly maxBufferSize;
+    private buffer;
+    private timeoutId;
+    constructor(config: IConfiguration, httpClient: IHttpClient);
+    stop(): void;
+    protected postActivities(activities: Activity[]): Promise<boolean>;
+    private addToBuffer;
+    private shouldFlush;
+    protected triggerFlush(): Promise<boolean>;
+    private flush;
+    protected clear(): void;
+    private startTimer;
+    private stopTimer;
+}

package/lib/activities/HttpBatchedActivityClient.js

@@ -0,0 +1,137 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpBatchedActivityClient = void 0;
+var HttpActivityClient_1 = require("./HttpActivityClient");
+var HttpBatchedActivityClient = /** @class */ (function (_super) {
+    __extends(HttpBatchedActivityClient, _super);
+    function HttpBatchedActivityClient(config, httpClient) {
+        var _this = _super.call(this, config, httpClient) || this;
+        _this.buffer = [];
+        _this.batchSize = config.maxActivityBatchSize;
+        _this.timeoutMs = config.activityBatchTimeoutMs;
+        _this.maxBufferSize = _this.batchSize * 2;
+        _this.startTimer();
+        return _this;
+    }
+    HttpBatchedActivityClient.prototype.stop = function () {
+        this.stopTimer();
+    };
+    HttpBatchedActivityClient.prototype.postActivities = function (activities) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.addToBuffer(activities);
+                return [2 /*return*/, this.shouldFlush() ? this.triggerFlush() : true];
+            });
+        });
+    };
+    HttpBatchedActivityClient.prototype.addToBuffer = function (activities) {
+        this.buffer = activities.concat(this.buffer);
+        if (this.buffer.length > this.maxBufferSize) {
+            this.buffer = this.buffer.slice(0, this.maxBufferSize);
+        }
+    };
+    HttpBatchedActivityClient.prototype.shouldFlush = function () {
+        return this.buffer.length >= this.batchSize;
+    };
+    HttpBatchedActivityClient.prototype.triggerFlush = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var sentSuccessfully, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.stopTimer();
+                        _a = this.buffer.length > 0;
+                        if (!_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.flush()];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        sentSuccessfully = _a;
+                        this.startTimer();
+                        return [2 /*return*/, sentSuccessfully];
+                }
+            });
+        });
+    };
+    HttpBatchedActivityClient.prototype.flush = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var sentSuccessfully;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _super.prototype.postActivities.call(this, this.buffer)];
+                    case 1:
+                        sentSuccessfully = _a.sent();
+                        if (sentSuccessfully) {
+                            this.clear();
+                        }
+                        return [2 /*return*/, sentSuccessfully];
+                }
+            });
+        });
+    };
+    HttpBatchedActivityClient.prototype.clear = function () {
+        this.buffer = [];
+    };
+    HttpBatchedActivityClient.prototype.startTimer = function () {
+        var _this = this;
+        this.timeoutId = setTimeout(function () { return _this.triggerFlush(); }, this.timeoutMs);
+    };
+    HttpBatchedActivityClient.prototype.stopTimer = function () {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = null;
+    };
+    return HttpBatchedActivityClient;
+}(HttpActivityClient_1.HttpActivityClient));
+exports.HttpBatchedActivityClient = HttpBatchedActivityClient;

package/lib/activities/index.d.ts

@@ -3,3 +3,4 @@ export { Activity } from './model/Activity';
 export { ActivityTypeDetails, ActivityDetails, BlockActivityDetails, PageRequestedActivityDetails, } from './model/ActivityDetails';
 export { ActivityType } from './ActivityType';
 export { HttpActivityClient } from './HttpActivityClient';
+export { HttpBatchedActivityClient } from './HttpBatchedActivityClient';

package/lib/activities/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpActivityClient = exports.ActivityType = void 0;
+exports.HttpBatchedActivityClient = exports.HttpActivityClient = exports.ActivityType = void 0;
 var ActivityType_1 = require("./ActivityType");
 Object.defineProperty(exports, "ActivityType", { enumerable: true, get: function () { return ActivityType_1.ActivityType; } });
 var HttpActivityClient_1 = require("./HttpActivityClient");
 Object.defineProperty(exports, "HttpActivityClient", { enumerable: true, get: function () { return HttpActivityClient_1.HttpActivityClient; } });
+var HttpBatchedActivityClient_1 = require("./HttpBatchedActivityClient");
+Object.defineProperty(exports, "HttpBatchedActivityClient", { enumerable: true, get: function () { return HttpBatchedActivityClient_1.HttpBatchedActivityClient; } });

package/lib/config/DefaultConfigurations.js

@@ -20,7 +20,7 @@ exports.DEFAULT_CONFIGURATIONS = {
     px_module_mode: ModuleMode_1.ModuleMode.MONITOR,
     px_additional_activity_handler: null,
     px_advanced_blocking_response_enabled: true,
-    px_max_activity_batch_size: 20,
+    px_max_activity_batch_size: 0,
     px_batch_activities_timeout_ms: 1000,
     px_bypass_monitor_header: '',
     px_csp_enabled: false,

package/lib/config/IConfiguration.d.ts

@@ -157,6 +157,14 @@ export interface IConfiguration<ParamsType extends ConfigurationParams = Configu
      * The maximum expected length of the user-agent beyond which it will be truncated.
      */
     readonly userAgentMaxLength: number;
+    /**
+     * The batch size at which asynchronous activities are sent to the collector.
+     */
+    readonly maxActivityBatchSize: number;
+    /**
+     * The maximum amount of time to wait before sending asynchronous activities to the collector.
+     */
+    readonly activityBatchTimeoutMs: number;
     /**
      * A function returning CustomParameters that will be added to the enforcer activities.
      */

package/lib/config/StaticConfigurationBase.d.ts

@@ -51,6 +51,8 @@ export declare abstract class StaticConfigurationBase<ParamsType extends Configu
     get riskCookieMinIterations(): number;
     get riskCookieMaxLength(): number;
     get userAgentMaxLength(): number;
+    get maxActivityBatchSize(): number;
+    get activityBatchTimeoutMs(): number;
     get enrichCustomParameters(): CustomParametersFunction;
     get additionalActivityHandler(): AdditionalActivityHandler;
     get altBackendCaptchaUrl(): string;

package/lib/config/StaticConfigurationBase.js

@@ -329,6 +329,20 @@ var StaticConfigurationBase = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(StaticConfigurationBase.prototype, "maxActivityBatchSize", {
+        get: function () {
+            return this.configParams.px_max_activity_batch_size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "activityBatchTimeoutMs", {
+        get: function () {
+            return this.configParams.px_batch_activities_timeout_ms;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(StaticConfigurationBase.prototype, "enrichCustomParameters", {
         get: function () {
             return this.configParams.px_enrich_custom_parameters || null;

package/lib/enforcer/EnforcerBase.js

@@ -75,7 +75,11 @@ var EnforcerBase = /** @class */ (function () {
         var httpClient = options.httpClient;
         this.firstParty = options.firstParty || new first_party_1.DefaultFirstParty(this.config, httpClient);
         this.telemetry = options.telemetry || new telemetry_1.DefaultTelemetry(this.config, httpClient, base64Utils, hashUtils);
-        this.activityClient = options.activityClient || new activities_1.HttpActivityClient(this.config, httpClient);
+        this.activityClient =
+            options.activityClient ||
+                (this.config.maxActivityBatchSize > 1
+                    ? new activities_1.HttpBatchedActivityClient(this.config, httpClient)
+                    : new activities_1.HttpActivityClient(this.config, httpClient));
         var riskResponseHandler = options.tokenVersion === risk_token_1.TokenVersion.V2
             ? new risk_api_1.RiskResponseV2Handler(this.config)
             : new risk_api_1.RiskResponseV3Handler(this.config);

package/lib/risk_api/PostRiskApiClient.d.ts

@@ -15,7 +15,20 @@ export declare class PostRiskApiClient<RiskResponseType extends RiskResponseV2 |
     shouldRetrieveScore(context: IContext): boolean;
     private unsetScoreFields;
     retrieveScore(context: IContext): Promise<boolean>;
+    /**
+     * Creates the RiskActivity payload
+     * @param context
+     * @returns RiskActivity
+     * @protected
+     */
     protected createRiskActivity(context: IContext): RiskActivity;
+    /**
+     * Protected function in case expansions or alterations to the risk activity are needed for certain platforms.
+     * @param riskActivity
+     * @returns RiskActivity
+     * @protected
+     */
+    protected finalizeRiskActivity(riskActivity: RiskActivity): RiskActivity;
     private addOptionalRiskFields;
     private addOptionalRiskFieldsToRoot;
     private addOptionalRiskFieldsToAdditional;

package/lib/risk_api/PostRiskApiClient.js

@@ -117,6 +117,12 @@ var PostRiskApiClient = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Creates the RiskActivity payload
+     * @param context
+     * @returns RiskActivity
+     * @protected
+     */
     PostRiskApiClient.prototype.createRiskActivity = function (context) {
         var riskActivity = {
             request: {
@@ -136,6 +142,15 @@ var PostRiskApiClient = /** @class */ (function () {
             },
         };
         this.addOptionalRiskFields(riskActivity, context);
+        return this.finalizeRiskActivity(riskActivity);
+    };
+    /**
+     * Protected function in case expansions or alterations to the risk activity are needed for certain platforms.
+     * @param riskActivity
+     * @returns RiskActivity
+     * @protected
+     */
+    PostRiskApiClient.prototype.finalizeRiskActivity = function (riskActivity) {
         return riskActivity;
     };
     PostRiskApiClient.prototype.addOptionalRiskFields = function (riskActivity, context) {

package/lib/risk_token/RiskTokenScoreRetriever.js

@@ -97,7 +97,7 @@ var RiskTokenScoreRetriever = /** @class */ (function () {
                     case 0: return [4 /*yield*/, token.verify(context)];
                     case 1:
                         result = _a.sent();
-                        if (result === TokenVerificationResult_1.TokenVerificationResult.DECRYPTION_FAILED) {
+                        if (result === TokenVerificationResult_1.TokenVerificationResult.DECRYPTION_FAILED || result === TokenVerificationResult_1.TokenVerificationResult.CANNOT_VERIFY) {
                             return [2 /*return*/, this.handleFailure(context, risk_api_1.S2SCallReason.COOKIE_DECRYPTION_FAILED)];
                         }
                         if (result === TokenVerificationResult_1.TokenVerificationResult.VALIDATION_FAILED) {

package/lib/utils/constants.d.ts

@@ -7,4 +7,4 @@ export declare const BYPASS_MONITOR_HEADER_VALUE = "1";
 export declare const X_PX_AUTHORIZATION_HEADER_NAME = "x-px-authorization";
 export declare const X_PX_ORIGINAL_TOKEN_HEADER_NAME = "x-px-original-token";
 export declare const X_PX_BYPASS_REASON_HEADER_NAME = "x-px-bypass-reason";
-export declare const CORE_MODULE_VERSION = "JS Core 0.1.1";
+export declare const CORE_MODULE_VERSION = "JS Core 0.2.0";

package/lib/utils/constants.js

@@ -10,4 +10,4 @@ exports.BYPASS_MONITOR_HEADER_VALUE = '1';
 exports.X_PX_AUTHORIZATION_HEADER_NAME = 'x-px-authorization';
 exports.X_PX_ORIGINAL_TOKEN_HEADER_NAME = 'x-px-original-token';
 exports.X_PX_BYPASS_REASON_HEADER_NAME = 'x-px-bypass-reason';
-exports.CORE_MODULE_VERSION = 'JS Core 0.1.1';
+exports.CORE_MODULE_VERSION = 'JS Core 0.2.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perimeterx-js-core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -15,7 +15,7 @@
     "test": "mocha",
     "coverage": "nyc npm run test",
     "pre-commit": "./node_modules/.bin/lint-staged",
-    "postinstall": "./node_modules/.bin/husky install"
+    "prepare": "husky install"
   },
   "dependencies": {
     "cookie": "^0.5.0",