perimeterx-js-core 0.29.0 → 0.30.0

package/lib/cjs/activities/HttpActivityClient.js

@@ -63,24 +63,21 @@ var HttpActivityClient = /** @class */ (function () {
      */
     HttpActivityClient.prototype.sendActivities = function (context) {
         return __awaiter(this, void 0, void 0, function () {
-            var activities, e_1;
+            var activities;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        activities = this.createActivities(context);
-                        if (!activities || activities.length === 0) {
-                            context.logger.debug('no activities to send');
-                            return [2 /*return*/, true];
-                        }
-                        return [4 /*yield*/, this.postActivities(activities, context.logger)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                    case 2:
-                        e_1 = _a.sent();
-                        context.logger.error("unable to send activities - ".concat(e_1));
-                        return [2 /*return*/, false];
-                    case 3: return [2 /*return*/];
+                try {
+                    activities = this.createActivities(context);
+                    if (!activities || activities.length === 0) {
+                        context.logger.debug('no activities to send');
+                        return [2 /*return*/, true];
+                    }
+                    return [2 /*return*/, this.postActivities(activities, context.logger)];
                 }
+                catch (e) {
+                    context.logger.error("unable to send activities - ".concat(e));
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
             });
         });
     };
@@ -171,11 +168,12 @@ var HttpActivityClient = /** @class */ (function () {
      */
     HttpActivityClient.prototype.postActivities = function (activities, logger) {
         return __awaiter(this, void 0, void 0, function () {
-            var url, method, headers, body, req, res;
+            var url, method, headers, body, req, res, e_1;
             var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
+                        _b.trys.push([0, 2, , 3]);
                         url = "".concat(this.config.backendCollectorUrl).concat(constants_1.ACTIVITIES_ENDPOINT);
                         method = http_1.HttpMethod.POST;
                         headers = (_a = {},
@@ -192,6 +190,11 @@ var HttpActivityClient = /** @class */ (function () {
                     case 1:
                         res = _b.sent();
                         return [2 /*return*/, (res === null || res === void 0 ? void 0 : res.status) === 200];
+                    case 2:
+                        e_1 = _b.sent();
+                        logger.error("failed to post activities - ".concat(e_1));
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
                 }
             });
         });

package/lib/cjs/config/ConfigurationBase.js

@@ -782,6 +782,13 @@ var ConfigurationBase = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(ConfigurationBase.prototype, "awaitAsyncHttpRequests", {
+        get: function () {
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(ConfigurationBase.prototype, "isPostEnforceEnabled", {
         get: function () {
             return true;

package/lib/cjs/flow/EndEnforcerFlow.js

@@ -23,8 +23,8 @@ var EndEnforcerFlow = /** @class */ (function (_super) {
     function EndEnforcerFlow(config, _a) {
         var logServiceClient = _a.logServiceClient, telemetry = _a.telemetry, remoteConfigManager = _a.remoteConfigManager, activityClient = _a.activityClient;
         var phases = [
-            new phase_1.SendAsyncActivitiesPhase(activityClient),
-            new phase_1.SendTelemetryActivityPhase(telemetry),
+            new phase_1.SendAsyncActivitiesPhase(config, activityClient),
+            new phase_1.SendTelemetryActivityPhase(config, telemetry),
         ];
         if (remoteConfigManager) {
             phases.push(new phase_1.UpdateRemoteConfigPhase(config, remoteConfigManager));

package/lib/cjs/phase/impl/SendAsyncActivitiesPhase.js

@@ -42,16 +42,20 @@ var action_1 = require("../../action/index.js");
  * The `SendAsyncActivitiesPhase` class is responsible for sending all necessary asynchronous activities based on the context.
  */
 var SendAsyncActivitiesPhase = /** @class */ (function () {
-    function SendAsyncActivitiesPhase(activityClient) {
+    function SendAsyncActivitiesPhase(config, activityClient) {
+        this.config = config;
         this.activityClient = activityClient;
     }
     SendAsyncActivitiesPhase.prototype.execute = function (context) {
         return __awaiter(this, void 0, void 0, function () {
+            var promise;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (![action_1.Action.PASS_REQUEST, action_1.Action.BLOCK, action_1.Action.SIMULATED_BLOCK].includes(context.action)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.activityClient.sendActivities(context)];
+                        promise = this.activityClient.sendActivities(context);
+                        if (!this.config.awaitAsyncHttpRequests) return [3 /*break*/, 2];
+                        return [4 /*yield*/, promise];
                     case 1:
                         _a.sent();
                         _a.label = 2;

package/lib/cjs/phase/impl/SendLogsPhase.js

@@ -41,16 +41,20 @@ exports.SendLogsPhase = void 0;
  * The `SendLogsPhase` class is responsible for sending logs to the HUMAN logging service.
  */
 var SendLogsPhase = /** @class */ (function () {
-    function SendLogsPhase(_config, logServiceClient) {
+    function SendLogsPhase(config, logServiceClient) {
+        this.config = config;
         this.logServiceClient = logServiceClient;
     }
     SendLogsPhase.prototype.execute = function (context) {
         return __awaiter(this, void 0, void 0, function () {
+            var promise;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (!context.shouldSendLogs) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.logServiceClient.sendLogs(context)];
+                        promise = this.logServiceClient.sendLogs(context);
+                        if (!this.config.awaitAsyncHttpRequests) return [3 /*break*/, 2];
+                        return [4 /*yield*/, promise];
                     case 1:
                         _a.sent();
                         _a.label = 2;

package/lib/cjs/phase/impl/SendTelemetryActivityPhase.js

@@ -41,16 +41,20 @@ exports.SendTelemetryActivityPhase = void 0;
  * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
  */
 var SendTelemetryActivityPhase = /** @class */ (function () {
-    function SendTelemetryActivityPhase(telemetry) {
+    function SendTelemetryActivityPhase(config, telemetry) {
+        this.config = config;
         this.telemetry = telemetry;
     }
     SendTelemetryActivityPhase.prototype.execute = function (context) {
         return __awaiter(this, void 0, void 0, function () {
+            var promise;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (!context.shouldSendTelemetry) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.telemetry.sendTelemetry(context)];
+                        promise = this.telemetry.sendTelemetry(context);
+                        if (!this.config.awaitAsyncHttpRequests) return [3 /*break*/, 2];
+                        return [4 /*yield*/, promise];
                     case 1:
                         _a.sent();
                         _a.label = 2;

package/lib/cjs/utils/constants.js

@@ -15,4 +15,4 @@ exports.PUSH_DATA_FEATURE_HEADER_NAME = 'x-px-feature';
 exports.EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$/;
 exports.URL_REGEX = /^(https?:)\/\/(([^@\s:\/]+):?([^@\s\/]*)@)?(([^:\/?#]*)(?:\:([0-9]+))?)(\/?[^?#]*)(\?[^#]*|)(#.*|)$/;
 exports.REGEX_STRUCTURE = /^\/(.+?)\/([gimsuyvd]*)$/;
-exports.CORE_MODULE_VERSION = 'JS Core 0.29.0';
+exports.CORE_MODULE_VERSION = 'JS Core 0.30.0';

package/lib/esm/activities/HttpActivityClient.js

@@ -31,7 +31,7 @@ export class HttpActivityClient {
                 context.logger.debug('no activities to send');
                 return true;
             }
-            return await this.postActivities(activities, context.logger);
+            return this.postActivities(activities, context.logger);
         }
         catch (e) {
             context.logger.error(`unable to send activities - ${e}`);
@@ -124,16 +124,22 @@ export class HttpActivityClient {
      * @protected
      */
     async postActivities(activities, logger) {
-        const url = `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`;
-        const method = HttpMethod.POST;
-        const headers = {
-            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
-            [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
-        };
-        const body = activities.length === 1 ? JSON.stringify(activities[0]) : JSON.stringify(activities);
-        logger.debug(`sending ${activities.map(({ type }) => `${type} activity`).join(', ')} to ${url}`);
-        const req = new OutgoingRequestImpl({ url, method, headers, body });
-        const res = await this.httpClient.send(req, { timeoutMs: this.config.asyncTimeout });
-        return res?.status === 200;
+        try {
+            const url = `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`;
+            const method = HttpMethod.POST;
+            const headers = {
+                [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+                [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
+            };
+            const body = activities.length === 1 ? JSON.stringify(activities[0]) : JSON.stringify(activities);
+            logger.debug(`sending ${activities.map(({ type }) => `${type} activity`).join(', ')} to ${url}`);
+            const req = new OutgoingRequestImpl({ url, method, headers, body });
+            const res = await this.httpClient.send(req, { timeoutMs: this.config.asyncTimeout });
+            return res?.status === 200;
+        }
+        catch (e) {
+            logger.error(`failed to post activities - ${e}`);
+            return false;
+        }
     }
 }

package/lib/esm/config/ConfigurationBase.js

@@ -408,6 +408,9 @@ export class ConfigurationBase {
     get enableBlockedUrlOnCaptchaBlockPage() {
         return true;
     }
+    get awaitAsyncHttpRequests() {
+        return true;
+    }
     get isPostEnforceEnabled() {
         return true;
     }

package/lib/esm/flow/EndEnforcerFlow.js

@@ -3,8 +3,8 @@ import { Flow } from './Flow.js';
 export class EndEnforcerFlow extends Flow {
     constructor(config, { logServiceClient, telemetry, remoteConfigManager, activityClient, }) {
         const phases = [
-            new SendAsyncActivitiesPhase(activityClient),
-            new SendTelemetryActivityPhase(telemetry),
+            new SendAsyncActivitiesPhase(config, activityClient),
+            new SendTelemetryActivityPhase(config, telemetry),
         ];
         if (remoteConfigManager) {
             phases.push(new UpdateRemoteConfigPhase(config, remoteConfigManager));

package/lib/esm/phase/impl/SendAsyncActivitiesPhase.js

@@ -3,13 +3,19 @@ import { Action } from '../../action/index.js';
  * The `SendAsyncActivitiesPhase` class is responsible for sending all necessary asynchronous activities based on the context.
  */
 export class SendAsyncActivitiesPhase {
+    config;
     activityClient;
-    constructor(activityClient) {
+    constructor(config, activityClient) {
+        this.config = config;
         this.activityClient = activityClient;
     }
     async execute(context) {
         if ([Action.PASS_REQUEST, Action.BLOCK, Action.SIMULATED_BLOCK].includes(context.action)) {
-            await this.activityClient.sendActivities(context);
+            // ensure error handling is done in the sendActivities method
+            const promise = this.activityClient.sendActivities(context);
+            if (this.config.awaitAsyncHttpRequests) {
+                await promise;
+            }
         }
         return { done: false };
     }

package/lib/esm/phase/impl/SendLogsPhase.js

@@ -2,13 +2,19 @@
  * The `SendLogsPhase` class is responsible for sending logs to the HUMAN logging service.
  */
 export class SendLogsPhase {
+    config;
     logServiceClient;
-    constructor(_config, logServiceClient) {
+    constructor(config, logServiceClient) {
+        this.config = config;
         this.logServiceClient = logServiceClient;
     }
     async execute(context) {
         if (context.shouldSendLogs) {
-            await this.logServiceClient.sendLogs(context);
+            // ensure error handling is done in the sendLogs method
+            const promise = this.logServiceClient.sendLogs(context);
+            if (this.config.awaitAsyncHttpRequests) {
+                await promise;
+            }
         }
         return { done: false };
     }

package/lib/esm/phase/impl/SendTelemetryActivityPhase.js

@@ -2,13 +2,19 @@
  * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
  */
 export class SendTelemetryActivityPhase {
+    config;
     telemetry;
-    constructor(telemetry) {
+    constructor(config, telemetry) {
+        this.config = config;
         this.telemetry = telemetry;
     }
     async execute(context) {
         if (context.shouldSendTelemetry) {
-            await this.telemetry.sendTelemetry(context);
+            // ensure error handling is done in the sendTelemetry method
+            const promise = this.telemetry.sendTelemetry(context);
+            if (this.config.awaitAsyncHttpRequests) {
+                await promise;
+            }
         }
         return { done: false };
     }

package/lib/esm/utils/constants.js

@@ -12,4 +12,4 @@ export const PUSH_DATA_FEATURE_HEADER_NAME = 'x-px-feature';
 export const EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$/;
 export const URL_REGEX = /^(https?:)\/\/(([^@\s:\/]+):?([^@\s\/]*)@)?(([^:\/?#]*)(?:\:([0-9]+))?)(\/?[^?#]*)(\?[^#]*|)(#.*|)$/;
 export const REGEX_STRUCTURE = /^\/(.+?)\/([gimsuyvd]*)$/;
-export const CORE_MODULE_VERSION = 'JS Core 0.29.0';
+export const CORE_MODULE_VERSION = 'JS Core 0.30.0';

package/lib/types/config/ConfigurationBase.d.ts

@@ -144,5 +144,6 @@ export declare abstract class ConfigurationBase<Req, Res, Added, Removed extends
     get snippetInjectionEnabled(): boolean;
     get createCustomSnippet(): CustomSnippetFunction<Req, Res, Added, Removed> | null;
     get enableBlockedUrlOnCaptchaBlockPage(): boolean;
+    get awaitAsyncHttpRequests(): boolean;
     get isPostEnforceEnabled(): boolean;
 }

package/lib/types/config/IConfiguration.d.ts

@@ -396,6 +396,10 @@ export interface IConfiguration<Req, Res, Added, Removed> {
      * Whether the enforcer has access to the HTTP response, which is required for the postEnforce function call
      */
     readonly isPostEnforceEnabled: boolean;
+    /**
+     * Whether to await asynchronous HTTP requests (e.g., async activities, remote logger, telemetry)
+     */
+    readonly awaitAsyncHttpRequests: boolean;
     /**
      * The version of the token the enforcer is able to parse.
      */

package/lib/types/phase/impl/SendAsyncActivitiesPhase.d.ts

@@ -1,3 +1,4 @@
+import { IConfiguration } from '../../config';
 import { IContext } from '../../context';
 import { IActivityClient } from '../../activities';
 import { PhaseResult } from '../PhaseResult';
@@ -5,8 +6,9 @@ import { IPhase } from '../IPhase';
 /**
  * The `SendAsyncActivitiesPhase` class is responsible for sending all necessary asynchronous activities based on the context.
  */
-export declare class SendAsyncActivitiesPhase<Req, Res> implements IPhase<Req, Res> {
+export declare class SendAsyncActivitiesPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
     protected readonly activityClient: IActivityClient<Req, Res>;
-    constructor(activityClient: IActivityClient<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Added, Removed>, activityClient: IActivityClient<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/phase/impl/SendLogsPhase.d.ts

@@ -7,7 +7,8 @@ import { ILogServiceClient } from '../../logger';
  * The `SendLogsPhase` class is responsible for sending logs to the HUMAN logging service.
  */
 export declare class SendLogsPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
+    private readonly config;
     private readonly logServiceClient;
-    constructor(_config: IConfiguration<Req, Res, Added, Removed>, logServiceClient: ILogServiceClient<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Added, Removed>, logServiceClient: ILogServiceClient<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/phase/impl/SendTelemetryActivityPhase.d.ts

@@ -2,12 +2,14 @@ import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
 import { IContext } from '../../context';
 import { ITelemetry } from '../../telemetry';
+import { IConfiguration } from '../../config';
 /**
  * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
  */
-export declare class SendTelemetryActivityPhase<Req, Res> implements IPhase<Req, Res> {
+export declare class SendTelemetryActivityPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
     protected readonly telemetry: ITelemetry<Req, Res>;
-    constructor(telemetry: ITelemetry<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Added, Removed>, telemetry: ITelemetry<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected sendTelemetry(context: IContext<Req, Res>): Promise<void>;
 }

package/lib/types/utils/constants.d.ts

@@ -12,4 +12,4 @@ export declare const PUSH_DATA_FEATURE_HEADER_NAME = "x-px-feature";
 export declare const EMAIL_ADDRESS_REGEX: RegExp;
 export declare const URL_REGEX: RegExp;
 export declare const REGEX_STRUCTURE: RegExp;
-export declare const CORE_MODULE_VERSION = "JS Core 0.29.0";
+export declare const CORE_MODULE_VERSION = "JS Core 0.30.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perimeterx-js-core",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "",
   "type": "module",
   "typesVersions": {