perimeterx-js-core 0.7.0 → 0.8.0

package/lib/phase/impl/PreflightPhase.js

@@ -1,28 +1,20 @@
-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());
-    });
-};
 export class PreflightPhase {
+    corsSupportEnabled;
+    filterPreflightRequestsEnabled;
+    cors;
     constructor(config, cors) {
         this.corsSupportEnabled = config.corsSupportEnabled;
         this.filterPreflightRequestsEnabled = config.corsPreflightRequestFilterEnabled;
         this.cors = cors;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.corsSupportEnabled || !this.cors.isPreflightRequest(context)) {
-                return { done: false };
-            }
-            const response = yield this.cors.runPreflightCustomHandler(context);
-            if (response) {
-                return { done: true, response };
-            }
-            return { done: this.filterPreflightRequestsEnabled };
-        });
+    async execute(context) {
+        if (!this.corsSupportEnabled || !this.cors.isPreflightRequest(context)) {
+            return { done: false };
+        }
+        const response = await this.cors.runPreflightCustomHandler(context);
+        if (response) {
+            return { done: true, response };
+        }
+        return { done: this.filterPreflightRequestsEnabled };
     }
 }

package/lib/phase/impl/RiskApiPhase.js

@@ -1,46 +1,36 @@
-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 { Action } from '../../action';
 import { transferExistingProperties } from '../../utils';
 import { DecideActionPhase } from './DecideActionPhase';
+import { ProductName } from '../../products';
 import { PXHDSource } from '../../pxhd';
 export class RiskApiPhase extends DecideActionPhase {
+    products;
+    riskApiClient;
     constructor(config, products, riskApiClient) {
         super(config);
         this.products = products;
         this.riskApiClient = riskApiClient;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.shouldTriggerRiskApi(context)) {
-                yield this.triggerRiskApi(context);
-                yield this.enrichContextFromRiskApi(context);
-                yield this.updateContextDecision(context);
-            }
-            return { done: false };
-        });
+    async execute(context) {
+        if (this.shouldTriggerRiskApi(context)) {
+            await this.triggerRiskApi(context);
+            await this.enrichContextFromRiskApi(context);
+            await this.updateContextDecision(context);
+        }
+        return { done: false };
     }
     shouldTriggerRiskApi(context) {
         return context.action === Action.TRIGGER_RISK_API;
     }
-    triggerRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const riskApiData = yield this.riskApiClient.executeRiskApi(context);
-            Object.assign(context.riskApiData, riskApiData);
-        });
+    async triggerRiskApi(context) {
+        context.riskApiData.s2sCallReason =
+            context.reasons?.[ProductName.BOT_DEFENDER] || context.reasons?.[ProductName.CREDENTIAL_INTELLIGENCE];
+        const riskApiData = await this.riskApiClient.executeRiskApi(context);
+        Object.assign(context.riskApiData, riskApiData);
     }
-    enrichContextFromRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.addRiskApiDataToContext(context);
-            yield this.enrichContextWithProductDataFromRiskApi(context);
-        });
+    async enrichContextFromRiskApi(context) {
+        this.addRiskApiDataToContext(context);
+        await this.enrichContextWithProductDataFromRiskApi(context);
     }
     addRiskApiDataToContext(context) {
         const { riskResponse } = context.riskApiData;
@@ -64,13 +54,11 @@ export class RiskApiPhase extends DecideActionPhase {
             };
         }
     }
-    enrichContextWithProductDataFromRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(Object.entries(this.products).map(([name, product]) => __awaiter(this, void 0, void 0, function* () {
-                if (context.productData[name]) {
-                    Object.assign(context.productData[name], yield (product === null || product === void 0 ? void 0 : product.enrichContextFromRiskApi(context)));
-                }
-            })));
-        });
+    async enrichContextWithProductDataFromRiskApi(context) {
+        await Promise.all(Object.entries(this.products).map(async ([name, product]) => {
+            if (context.productData[name]) {
+                Object.assign(context.productData[name], await product?.enrichContextFromRiskApi(context));
+            }
+        }));
     }
 }

package/lib/phase/impl/SendAsyncActivitiesOnRequestPhase.js

@@ -1,28 +1,16 @@
-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 { Action } from '../../action';
 export class SendAsyncActivitiesOnRequestPhase {
+    activityClient;
     constructor(activityClient) {
         this.activityClient = activityClient;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (context.action === Action.BLOCK) {
-                yield this.sendAsyncActivity(context);
-            }
-            return { done: false };
-        });
+    async execute(context) {
+        if (context.action === Action.BLOCK) {
+            await this.sendAsyncActivity(context);
+        }
+        return { done: false };
     }
-    sendAsyncActivity(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.activityClient.sendActivities(context);
-        });
+    async sendAsyncActivity(context) {
+        await this.activityClient.sendActivities(context);
     }
 }

package/lib/phase/impl/SendAsyncActivitiesOnResponsePhase.js

@@ -1,20 +1,10 @@
-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());
-    });
-};
 export class SendAsyncActivitiesOnResponsePhase {
+    activityClient;
     constructor(activityClient) {
         this.activityClient = activityClient;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.activityClient.sendActivities(context);
-            return { done: false };
-        });
+    async execute(context) {
+        await this.activityClient.sendActivities(context);
+        return { done: false };
     }
 }

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

@@ -0,0 +1,11 @@
+import { IContext } from '../../context';
+import { IPhase } from '../IPhase';
+import { PhaseResult } from '../PhaseResult';
+import { IConfiguration } from '../../config';
+import { ILogServiceClient } from '../../logger';
+export declare class SendLogsPhase<Req, Res> implements IPhase<Req, Res> {
+    private readonly config;
+    private readonly logServiceClient;
+    constructor(config: IConfiguration<Req, Res>, logServiceClient: ILogServiceClient<Req, Res>);
+    execute(context: IContext<Req, Res>): Promise<PhaseResult>;
+}

package/lib/phase/impl/SendLogsPhase.js

@@ -0,0 +1,16 @@
+import { X_PX_ENFORCER_LOG_HEADER } from '../../logger';
+export class SendLogsPhase {
+    config;
+    logServiceClient;
+    constructor(config, logServiceClient) {
+        this.config = config;
+        this.logServiceClient = logServiceClient;
+    }
+    async execute(context) {
+        const headerValue = context.requestData.headers[X_PX_ENFORCER_LOG_HEADER]?.[0];
+        if (headerValue == this.config.loggerAuthToken) {
+            await this.logServiceClient.sendLogs(context, this.config.logger.getLogs());
+        }
+        return { done: false };
+    }
+}

package/lib/phase/impl/TelemetryPhase.js

@@ -1,29 +1,17 @@
-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());
-    });
-};
 export class TelemetryPhase {
+    telemetry;
     constructor(telemetry) {
         this.telemetry = telemetry;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (yield this.telemetry.isValidTelemetryRequest(context)) {
-                yield this.sendTelemetry(context);
-                return { done: true };
-            }
-            return { done: false };
-        });
+    async execute(context) {
+        if (await this.telemetry.isValidTelemetryRequest(context)) {
+            await this.sendTelemetry(context);
+            return { done: true };
+        }
+        return { done: false };
     }
     // Note: If await is not necessary, can be overridden
-    sendTelemetry(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.telemetry.sendTelemetry(context);
-        });
+    async sendTelemetry(context) {
+        await this.telemetry.sendTelemetry(context);
     }
 }

package/lib/phase/impl/index.d.ts

@@ -14,3 +14,4 @@ export * from './SendAsyncActivitiesOnRequestPhase';
 export * from './SendAsyncActivitiesOnResponsePhase';
 export * from './AdditionalActivityHandlerPhase';
 export * from './CompositePhase';
+export * from './SendLogsPhase';

package/lib/phase/impl/index.js

@@ -14,3 +14,4 @@ export * from './SendAsyncActivitiesOnRequestPhase';
 export * from './SendAsyncActivitiesOnResponsePhase';
 export * from './AdditionalActivityHandlerPhase';
 export * from './CompositePhase';
+export * from './SendLogsPhase';

package/lib/products/account_defender/AccountDefender.js

@@ -1,48 +1,30 @@
-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 { getPropertyFromObject } from '../../utils';
 import { CROSS_TAB_SESSION_COOKIE_NAME } from './constants';
 export class AccountDefender {
+    config;
+    base64Utils;
     constructor(config, options) {
         this.config = config;
         this.base64Utils = options.base64Utils;
     }
-    enrichContextFromRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const crossTabSession = context.requestData.cookies[CROSS_TAB_SESSION_COOKIE_NAME];
-            const jwtData = this.getJwtData(context.requestData);
-            return Object.assign({ crossTabSession }, jwtData);
-        });
+    async enrichContextFromRequest(context) {
+        const crossTabSession = context.requestData.cookies[CROSS_TAB_SESSION_COOKIE_NAME];
+        const jwtData = this.getJwtData(context.requestData);
+        return { crossTabSession, ...jwtData };
     }
-    enrichContextFromRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async enrichContextFromRiskApi(context) {
+        return;
     }
-    enrichContextFromResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async enrichContextFromResponse(context) {
+        return;
     }
-    modifyIncomingRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async modifyIncomingRequest(context) {
+        return;
     }
-    modifyOutgoingResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async modifyOutgoingResponse(context) {
+        return;
     }
     getJwtData(requestData) {
-        var _a;
         let jwtToken;
         let userIdFieldName;
         let additionalFieldNames;
@@ -54,7 +36,7 @@ export class AccountDefender {
             }
         }
         if (!jwtToken && this.config.jwtHeaderName) {
-            jwtToken = (_a = requestData.headers[this.config.jwtHeaderName]) === null || _a === void 0 ? void 0 : _a[0];
+            jwtToken = requestData.headers[this.config.jwtHeaderName]?.[0];
             if (jwtToken) {
                 userIdFieldName = this.config.jwtHeaderUserIdFieldName;
                 additionalFieldNames = this.config.jwtHeaderAdditionalFieldNames;
@@ -84,9 +66,8 @@ export class AccountDefender {
         return null;
     }
     getDecodedJwt(jwt) {
-        var _a;
         try {
-            const encodedPayload = (_a = jwt.split('.')) === null || _a === void 0 ? void 0 : _a[1];
+            const encodedPayload = jwt.split('.')?.[1];
             const base64 = encodedPayload.replace('-', '+').replace('_', '/');
             return JSON.parse(this.base64Utils.base64Decode(base64));
         }

package/lib/products/bot_defender/BotDefender.js

@@ -1,12 +1,3 @@
-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 { Action } from '../../action';
 import { TokenParseResult } from '../../risk_token';
 import { RiskApiCallResult } from '../../risk_api';
@@ -18,30 +9,31 @@ import { BotDefenderBlockReason, BotDefenderPassReason, BotDefenderS2SCallReason
 import { BotDefenderUtils } from './BotDefenderUtils';
 import { DefaultBotDefenderBlocker } from './block';
 export class BotDefender {
+    config;
+    firstParty;
+    filter;
+    blocker;
     constructor(config, options) {
-        var _a, _b, _c;
         this.config = config;
-        this.firstParty = (_a = options.firstParty) !== null && _a !== void 0 ? _a : new DefaultBotDefenderFirstParty(config);
-        this.filter = (_b = options.filter) !== null && _b !== void 0 ? _b : new DefaultBotDefenderFilter(config, options.ipRangeChecker);
-        this.blocker = (_c = options.blocker) !== null && _c !== void 0 ? _c : new DefaultBotDefenderBlocker(config, options.base64Utils);
+        this.firstParty = options.firstParty ?? new DefaultBotDefenderFirstParty(config);
+        this.filter = options.filter ?? new DefaultBotDefenderFilter(config, options.ipRangeChecker);
+        this.blocker = options.blocker ?? new DefaultBotDefenderBlocker(config, options.base64Utils);
     }
-    handleFirstPartyRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.firstParty.handleFirstPartyRequest(context);
-        });
+    async handleFirstPartyRequest(context) {
+        return this.firstParty.handleFirstPartyRequest(context);
     }
     shouldFilter(context) {
         return this.filter.shouldFilter(context);
     }
-    enrichContextFromRequest(context) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const isMonitoredRequest = this.isMonitoredRoute(context);
-            const isSensitiveRequest = this.isSensitiveRequest(context) || ((_a = context.graphqlData) === null || _a === void 0 ? void 0 : _a.some((operation) => operation.sensitive));
-            const actionData = yield this.getTokenAction(context, isMonitoredRequest, isSensitiveRequest);
-            return Object.assign(Object.assign({}, actionData), { isMonitoredRequest,
-                isSensitiveRequest });
-        });
+    async enrichContextFromRequest(context) {
+        const isMonitoredRequest = this.isMonitoredRoute(context);
+        const isSensitiveRequest = this.isSensitiveRequest(context) || context.graphqlData?.some((operation) => operation.sensitive);
+        const actionData = await this.getTokenAction(context, isMonitoredRequest, isSensitiveRequest);
+        return {
+            ...actionData,
+            isMonitoredRequest,
+            isSensitiveRequest,
+        };
     }
     isMonitoredRoute(context) {
         return isMonitoredRequest(this.config, context);
@@ -50,28 +42,23 @@ export class BotDefender {
         // TODO: Include custom sensitive request function
         return isRouteInPatterns(url.pathname, this.config.sensitiveRoutes);
     }
-    enrichContextFromResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
-    }
-    getTokenAction(context, isMonitoredRequest, isSensitiveRequest) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (context.tokenData.tokenParseResult) {
-                case TokenParseResult.NONE:
-                    return new BotDefenderActionData(Action.TRIGGER_RISK_API, this.getNoTokenS2SCallReason(context));
-                case TokenParseResult.DECRYPTION_FAILED:
-                    return new BotDefenderActionData(Action.TRIGGER_RISK_API, BotDefenderS2SCallReason.COOKIE_DECRYPTION_FAILED);
-                case TokenParseResult.VALIDATION_FAILED:
-                    return new BotDefenderActionData(Action.TRIGGER_RISK_API, BotDefenderS2SCallReason.COOKIE_VALIDATION_FAILED);
-                case TokenParseResult.SUCCESSFUL:
-                    return this.getActionForSuccessfulTokenParse(context, isMonitoredRequest, isSensitiveRequest);
-            }
-        });
+    async enrichContextFromResponse(context) {
+        return;
+    }
+    async getTokenAction(context, isMonitoredRequest, isSensitiveRequest) {
+        switch (context.tokenData.tokenParseResult) {
+            case TokenParseResult.NONE:
+                return new BotDefenderActionData(Action.TRIGGER_RISK_API, this.getNoTokenS2SCallReason(context));
+            case TokenParseResult.DECRYPTION_FAILED:
+                return new BotDefenderActionData(Action.TRIGGER_RISK_API, BotDefenderS2SCallReason.COOKIE_DECRYPTION_FAILED);
+            case TokenParseResult.VALIDATION_FAILED:
+                return new BotDefenderActionData(Action.TRIGGER_RISK_API, BotDefenderS2SCallReason.COOKIE_VALIDATION_FAILED);
+            case TokenParseResult.SUCCESSFUL:
+                return this.getActionForSuccessfulTokenParse(context, isMonitoredRequest, isSensitiveRequest);
+        }
     }
     getNoTokenS2SCallReason({ pxhd, isMobile, tokenData, }) {
-        var _a;
-        if (isMobile && ((_a = tokenData.mobileData) === null || _a === void 0 ? void 0 : _a.mobileError)) {
+        if (isMobile && tokenData.mobileData?.mobileError) {
             return BotDefenderUtils.getS2SCallReasonFromMobileError(tokenData.mobileData.mobileError);
         }
         if (pxhd) {
@@ -91,24 +78,20 @@ export class BotDefender {
         }
         return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.COOKIE);
     }
-    enrichContextFromRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.getRiskApiActionData(context);
-        });
-    }
-    getRiskApiActionData({ riskApiData, productData: { bd }, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (riskApiData.riskApiCallResult) {
-                case RiskApiCallResult.NONE:
-                    throw new EnforcerError('risk api call result should not be none!');
-                case RiskApiCallResult.ERROR:
-                    return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.S2S_ERROR);
-                case RiskApiCallResult.TIMEOUT:
-                    return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.S2S_TIMEOUT);
-                case RiskApiCallResult.SUCCESSFUL:
-                    return this.getSuccessfulRiskApiAction(riskApiData.riskResponse, bd.isMonitoredRequest);
-            }
-        });
+    async enrichContextFromRiskApi(context) {
+        return await this.getRiskApiActionData(context);
+    }
+    async getRiskApiActionData({ riskApiData, productData: { bd }, }) {
+        switch (riskApiData.riskApiCallResult) {
+            case RiskApiCallResult.NONE:
+                throw new EnforcerError('risk api call result should not be none!');
+            case RiskApiCallResult.ERROR:
+                return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.S2S_ERROR);
+            case RiskApiCallResult.TIMEOUT:
+                return new BotDefenderActionData(Action.PASS_REQUEST, BotDefenderPassReason.S2S_TIMEOUT);
+            case RiskApiCallResult.SUCCESSFUL:
+                return this.getSuccessfulRiskApiAction(riskApiData.riskResponse, bd.isMonitoredRequest);
+        }
     }
     getSuccessfulRiskApiAction(riskResponse, isMonitored) {
         if (riskResponse.score >= this.config.blockingScore) {
@@ -122,14 +105,10 @@ export class BotDefender {
     createBlockResponse(context) {
         return this.blocker.createBlockResponse(context);
     }
-    modifyIncomingRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // intentionally left blank
-        });
+    async modifyIncomingRequest(context) {
+        // intentionally left blank
     }
-    modifyOutgoingResponse(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // intentionally left blank
-        });
+    async modifyOutgoingResponse(context) {
+        // intentionally left blank
     }
 }

package/lib/products/bot_defender/BotDefenderActionData.js

@@ -1,4 +1,6 @@
 export class BotDefenderActionData {
+    action;
+    reason;
     constructor(action, reason) {
         this.action = action;
         this.reason = reason;

package/lib/products/bot_defender/block/DefaultBotDefenderBlocker.d.ts

@@ -1,14 +1,14 @@
 import { ReadonlyContext } from '../../../context';
 import { IConfiguration } from '../../../config';
 import { IBase64Utils } from '../../../utils';
-import { IConditionalBlocker } from '../../../blocker';
+import { IBlocker, IConditionalBlocker } from '../../../blocker';
 import { IMinimalResponse } from '../../../http';
 export declare class DefaultBotDefenderBlocker<Req, Res> implements IConditionalBlocker<Req, Res> {
-    private readonly config;
-    private readonly captchaResponseGenerator;
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly captchaBlocker: IBlocker<Req, Res>;
     constructor(config: IConfiguration<Req, Res>, base64Utils: IBase64Utils);
     shouldBlock({ action, reasons, productData }: ReadonlyContext<Req, Res>): boolean;
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
-    private createRateLimitResponse;
+    protected createRateLimitResponse(): IMinimalResponse;
     private createCaptchaResponse;
 }

package/lib/products/bot_defender/block/DefaultBotDefenderBlocker.js

@@ -5,12 +5,14 @@ import { ProductName } from '../../utils';
 import { CaptchaBlocker } from './captcha';
 import { RATE_LIMIT_TEMPLATE } from './templates';
 export class DefaultBotDefenderBlocker {
+    config;
+    captchaBlocker;
     constructor(config, base64Utils) {
         this.config = config;
-        this.captchaResponseGenerator = new CaptchaBlocker(config, base64Utils);
+        this.captchaBlocker = new CaptchaBlocker(config, base64Utils);
     }
     shouldBlock({ action, reasons, productData }) {
-        return action === Action.BLOCK && !!(reasons === null || reasons === void 0 ? void 0 : reasons[ProductName.BOT_DEFENDER]);
+        return action === Action.BLOCK && !!reasons?.[ProductName.BOT_DEFENDER];
     }
     createBlockResponse(context) {
         switch (context.blockAction) {
@@ -34,6 +36,6 @@ export class DefaultBotDefenderBlocker {
         });
     }
     createCaptchaResponse(context) {
-        return this.captchaResponseGenerator.createBlockResponse(context);
+        return this.captchaBlocker.createBlockResponse(context);
     }
 }

package/lib/products/bot_defender/block/captcha/CaptchaBlocker.d.ts

@@ -3,11 +3,14 @@ import { ReadonlyContext } from '../../../../context';
 import { IBase64Utils } from '../../../../utils';
 import { IBlocker } from '../../../../blocker';
 import { IMinimalResponse } from '../../../../http';
+import { JsonCaptchaBlocker } from './JsonCaptchaBlocker';
+import { MobileCaptchaBlocker } from './MobileCaptchaBlocker';
+import { HtmlCaptchaBlocker } from './HtmlCaptchaBlocker';
 export declare class CaptchaBlocker<Req, Res> implements IBlocker<Req, Res> {
-    private readonly config;
-    private readonly jsonCaptchaGenerator;
-    private readonly mobileCaptchaGenerator;
-    private readonly htmlCaptchaGenerator;
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly jsonCaptchaBlocker: JsonCaptchaBlocker<Req, Res>;
+    protected readonly mobileCaptchaBlocker: MobileCaptchaBlocker<Req, Res>;
+    protected readonly htmlCaptchaBlocker: HtmlCaptchaBlocker<Req, Res>;
     constructor(config: IConfiguration<Req, Res>, base64Utils: IBase64Utils);
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
 }

package/lib/products/bot_defender/block/captcha/CaptchaBlocker.js

@@ -2,19 +2,23 @@ import { JsonCaptchaBlocker } from './JsonCaptchaBlocker';
 import { MobileCaptchaBlocker } from './MobileCaptchaBlocker';
 import { HtmlCaptchaBlocker } from './HtmlCaptchaBlocker';
 export class CaptchaBlocker {
+    config;
+    jsonCaptchaBlocker;
+    mobileCaptchaBlocker;
+    htmlCaptchaBlocker;
     constructor(config, base64Utils) {
         this.config = config;
-        this.jsonCaptchaGenerator = new JsonCaptchaBlocker(config);
-        this.mobileCaptchaGenerator = new MobileCaptchaBlocker(config, base64Utils);
-        this.htmlCaptchaGenerator = new HtmlCaptchaBlocker(config);
+        this.jsonCaptchaBlocker = new JsonCaptchaBlocker(config);
+        this.mobileCaptchaBlocker = new MobileCaptchaBlocker(config, base64Utils);
+        this.htmlCaptchaBlocker = new HtmlCaptchaBlocker(config);
     }
     createBlockResponse(context) {
-        if (this.mobileCaptchaGenerator.shouldBlock(context)) {
-            return this.mobileCaptchaGenerator.createBlockResponse(context);
+        if (this.mobileCaptchaBlocker.shouldBlock(context)) {
+            return this.mobileCaptchaBlocker.createBlockResponse(context);
         }
-        if (this.jsonCaptchaGenerator.shouldBlock(context)) {
-            return this.jsonCaptchaGenerator.createBlockResponse(context);
+        if (this.jsonCaptchaBlocker.shouldBlock(context)) {
+            return this.jsonCaptchaBlocker.createBlockResponse(context);
         }
-        return this.htmlCaptchaGenerator.createBlockResponse(context);
+        return this.htmlCaptchaBlocker.createBlockResponse(context);
     }
 }

package/lib/products/bot_defender/block/captcha/HtmlCaptchaBlocker.d.ts

@@ -3,7 +3,7 @@ import { ReadonlyContext } from '../../../../context';
 import { IBlocker } from '../../../../blocker';
 import { IMinimalResponse } from '../../../../http';
 export declare class HtmlCaptchaBlocker<Req, Res> implements IBlocker<Req, Res> {
-    private readonly config;
+    protected readonly config: IConfiguration<Req, Res>;
     constructor(config: IConfiguration<Req, Res>);
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
 }