perimeterx-js-core 0.7.1 → 0.8.0

package/lib/activities/utils.js

@@ -1,18 +1,18 @@
-import { removeSensitiveHeaders, transferExistingProperties } from '../utils';
-import { joinHeaderValues } from '../http';
+import { ModuleMode, removeSensitiveHeaders, transferExistingProperties } from '../utils';
+import { ProductName } from '../products';
 import { BLOCK_ACTION_TO_PRODUCT_MAP } from '../blocker';
 import { Action } from '../action';
 import { ActivityType } from './ActivityType';
-export const createActivity = (activityType, config, context) => {
-    var _a;
+import { TokenParseResult } from '../risk_token';
+export const createAsyncActivity = (activityType, config, context) => {
     return {
         type: activityType,
         px_app_id: config.appId,
         url: context.requestData.rawUrl,
         headers: activityType !== ActivityType.ADDITIONAL_S2S
-            ? joinHeaderValues(removeSensitiveHeaders(context.requestData.headers, config.sensitiveHeaders))
+            ? toHeaderEntryArray(removeSensitiveHeaders(context.requestData.headers, config.sensitiveHeaders))
             : undefined,
-        pxhd: (_a = context.pxhd) === null || _a === void 0 ? void 0 : _a.value,
+        pxhd: context.pxhd?.value,
         socket_ip: context.requestData.ip,
         timestamp: Date.now(),
         vid: context.vid,
@@ -20,7 +20,8 @@ export const createActivity = (activityType, config, context) => {
     };
 };
 export const createActivityDetails = (activityType, config, context) => {
-    const genericActivityDetails = createGenericActivityDetails(config, context);
+    const commonActivityDetails = createCommonActivityDetails(config, context);
+    const commonAsyncActivityDetails = createAsyncActivityCommonDetails(context);
     let specificActivityDetails = {};
     switch (activityType) {
         case ActivityType.PAGE_REQUESTED:
@@ -33,38 +34,43 @@ export const createActivityDetails = (activityType, config, context) => {
             specificActivityDetails = createAdditionalS2SActivityDetails(config, context);
             break;
     }
-    return Object.assign(genericActivityDetails, specificActivityDetails);
+    return Object.assign(commonActivityDetails, commonAsyncActivityDetails, specificActivityDetails);
 };
-export const createGenericActivityDetails = (config, context) => {
-    const genericActivityDetails = {
+export const createAsyncActivityCommonDetails = (context) => {
+    const details = {
+        client_uuid: context.uuid,
+    };
+    addRiskApiDataToAsyncActivityCommonDetails(details, context);
+    addResponseDataToAsyncActivityCommonDetails(details, context);
+    return details;
+};
+export const createCommonActivityDetails = (config, context) => {
+    const details = {
         module_version: config.moduleVersion,
+        // Note: risk_mode currently reflects only Bot Defender mode
+        risk_mode: context.productData.bd?.isMonitoredRequest ? ModuleMode.MONITOR : ModuleMode.ACTIVE_BLOCKING,
     };
-    if (context.customParameters) {
-        Object.assign(genericActivityDetails, context.customParameters);
-    }
-    transferExistingProperties(context, genericActivityDetails, {
+    addRootContextDataToDetails(details, context);
+    addRequestDataToDetails(details, context.requestData);
+    addTokenDataToDetails(details, context.tokenData);
+    addProductDataToDetails(details, context.productData);
+    addServerDataToDetails(details, context.serverData);
+    addTlsDataToDetails(details, context.tlsData);
+    addCustomParametersToDetails(details, context.customParameters);
+    return details;
+};
+export const addRootContextDataToDetails = (details, context) => {
+    transferExistingProperties(context, details, {
         requestId: 'request_id',
-        uuid: 'client_uuid',
         tokenOrigin: 'cookie_origin',
+        vidSource: 'enforcer_vid_source',
         graphqlData: 'graphql_operations',
     });
-    transferExistingProperties(context.requestData, genericActivityDetails, {
-        httpVersion: 'http_version',
-        method: 'http_method',
-        requestCookieNames: 'request_cookie_names',
-    });
-    transferExistingProperties(context.riskApiData, genericActivityDetails, {
-        riskRtt: 'risk_rtt',
-    });
-    transferExistingProperties(context.serverData, genericActivityDetails, {
-        region: 'server_info_region',
-        datacenter: 'server_info_datacenter',
-    });
-    transferExistingProperties(context.response, genericActivityDetails, {
-        status: 'http_status_code',
-    });
-    addProductDataToDetails(genericActivityDetails, context.productData);
-    return genericActivityDetails;
+};
+export const addCustomParametersToDetails = (details, customParameters) => {
+    if (customParameters) {
+        Object.assign(details, customParameters);
+    }
 };
 export const addProductDataToDetails = (details, productData) => {
     transferExistingProperties(productData.ad, details, {
@@ -73,9 +79,74 @@ export const addProductDataToDetails = (details, productData) => {
         crossTabSession: 'cross_tab_session',
     });
     transferExistingProperties(productData.ci, details, {
+        hashedUsername: 'user',
+        hashedPassword: 'pass',
         ciVersion: 'ci_version',
         ssoStep: 'sso_step',
-        isCompromised: 'credentials_compromised',
+    });
+};
+export const addTlsDataToDetails = (details, tlsData) => {
+    transferExistingProperties(tlsData, details, {
+        tlsProtocol: 'tls_protocol',
+        tlsServer: 'tls_server',
+        tlsCipher: 'tls_cipher',
+        tlsCiphersSha: 'tls_ciphers_sha',
+        tlsExtensionSha: 'tls_extension_sha',
+        tlsPreferredCiphers: 'tls_preferred_ciphers',
+        tlsJa3Fingerprint: 'tls_ja3_fingerprint',
+    });
+};
+export const addServerDataToDetails = (details, serverData) => {
+    transferExistingProperties(serverData, details, {
+        region: 'server_info_region',
+        datacenter: 'server_info_datacenter',
+    });
+};
+export const addRequestDataToDetails = (details, requestData) => {
+    transferExistingProperties(requestData, details, {
+        httpVersion: 'http_version',
+        method: 'http_method',
+        requestCookieNames: 'request_cookie_names',
+    });
+};
+export const addTokenDataToDetails = (details, { token, mobileData }) => {
+    if (token) {
+        if (token.isValid()) {
+            details.px_cookie = token.getPayloadString();
+            details.px_cookie_hmac = token.hmac;
+        }
+        else {
+            details.px_orig_cookie = token.getTokenString();
+        }
+    }
+    if (mobileData) {
+        transferExistingProperties(mobileData, details, {
+            originalToken: 'original_token',
+            decodedOriginalToken: 'px_decoded_original_token',
+        });
+        if (mobileData.originalTokenParseResult === TokenParseResult.DECRYPTION_FAILED) {
+            details.original_token_error = 'cookie_decryption_failed';
+        }
+        else if (mobileData.originalTokenParseResult === TokenParseResult.VALIDATION_FAILED) {
+            details.original_token_error = 'cookie_validation_failed';
+        }
+    }
+};
+export const addRiskApiDataToAsyncActivityCommonDetails = (details, context) => {
+    transferExistingProperties(context.riskApiData, details, {
+        riskRtt: 'risk_rtt',
+        s2sCallReason: 's2s_call_reason',
+    });
+    if (context.riskApiData.riskResponse?.additionalRiskInfo) {
+        details.additional_risk_info = context.riskApiData.riskResponse.additionalRiskInfo;
+    }
+    if (context.productData[ProductName.CREDENTIAL_INTELLIGENCE]) {
+        details.credentials_compromised = context.productData[ProductName.CREDENTIAL_INTELLIGENCE].isCompromised;
+    }
+};
+export const addResponseDataToAsyncActivityCommonDetails = (details, context) => {
+    transferExistingProperties(context.response, details, {
+        status: 'http_status_code',
     });
 };
 export const createPageRequestedActivityDetails = (context) => {
@@ -91,10 +162,9 @@ export const createPageRequestedActivityDetails = (context) => {
     return details;
 };
 export const createBlockActivityDetails = (context) => {
-    var _a;
     const details = {};
     const blockingProduct = BLOCK_ACTION_TO_PRODUCT_MAP.get(context.blockAction);
-    details.block_reason = (_a = context.reasons) === null || _a === void 0 ? void 0 : _a[blockingProduct];
+    details.block_reason = context.reasons?.[blockingProduct];
     details.simulated_block = context.action === Action.SIMULATED_BLOCK;
     transferExistingProperties(context, details, {
         blockAction: 'block_action',
@@ -112,3 +182,9 @@ export const createAdditionalS2SActivityDetails = ({ ciSendRawUsernameOnAddition
     }
     return details;
 };
+export const toHeaderEntryArray = (headers) => {
+    return Object.entries(headers).flatMap(([key, values]) => values.map((value) => ({
+        name: key,
+        value: value,
+    })));
+};

package/lib/additional_activity_handler/AdditionalActivityHandler.d.ts

@@ -1,3 +1,3 @@
 import { ConfigurationParams } from '../config';
 import { ReadonlyContext } from '../context';
-export type AdditionalActivityHandler = <Req, Res>(config: ConfigurationParams<Req, Res>, context: ReadonlyContext<Req, Res>, request: Req) => void | Promise<void>;
+export type AdditionalActivityHandler<Req, Res> = (config: ConfigurationParams<Req, Res>, context: ReadonlyContext<Req, Res>, request: Req) => void | Promise<void>;

package/lib/additional_activity_handler/AdditionalActivityHandlerUtils.js

@@ -1,22 +1,14 @@
-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 var AdditionalActivityHandlerUtils;
 (function (AdditionalActivityHandlerUtils) {
-    AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler = (config, context) => __awaiter(this, void 0, void 0, function* () {
+    AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler = async (config, context) => {
         if (config.additionalActivityHandler && typeof config.additionalActivityHandler === 'function') {
             try {
-                yield config.additionalActivityHandler(config.toParams(), context, context.requestData.request.getUnderlyingRequest());
+                config.logger.debug('calling additional activity handler');
+                await config.additionalActivityHandler(config.toParams(), context, context.requestData.request.getUnderlyingRequest());
             }
             catch (e) {
                 config.logger.error(`caught additional activity handler error - ${e}`);
             }
         }
-    });
+    };
 })(AdditionalActivityHandlerUtils || (AdditionalActivityHandlerUtils = {}));

package/lib/config/ConfigurationParams.d.ts

@@ -75,7 +75,7 @@ export type ConfigurationParams<Req, Res> = {
     px_cors_preflight_request_filter_enabled?: boolean;
     px_logger_auth_token?: string;
     px_extract_ip?: () => {};
-    px_additional_activity_handler?: AdditionalActivityHandler;
+    px_additional_activity_handler?: AdditionalActivityHandler<Req, Res>;
     px_enrich_custom_parameters?: CustomParametersFunction<Req, Res>;
     px_login_successful_custom_callback?: CustomLoginSuccessfulCallback<Res>;
     px_cors_custom_preflight_handler?: CustomPreflightHandler<Req>;

package/lib/config/IConfiguration.d.ts

@@ -207,7 +207,7 @@ export interface IConfiguration<Req, Res, ParamsType extends ConfigurationParams
     /**
      * A function that will be called after the asynchronous activities are sent to the backend.
      */
-    readonly additionalActivityHandler: AdditionalActivityHandler;
+    readonly additionalActivityHandler: AdditionalActivityHandler<Req, Res>;
     /**
      * Whether cors support feature should be enabled.
      */

package/lib/config/StaticConfigurationBase.d.ts

@@ -63,7 +63,7 @@ export declare abstract class StaticConfigurationBase<Req, Res, ParamsType exten
     get sensitiveGraphqlOperationNames(): string[];
     get sensitiveGraphqlOperationTypes(): string[];
     get enrichCustomParameters(): CustomParametersFunction<Req, Res>;
-    get additionalActivityHandler(): AdditionalActivityHandler;
+    get additionalActivityHandler(): AdditionalActivityHandler<Req, Res>;
     get altBackendCaptchaUrl(): string;
     get corsSupportEnabled(): boolean;
     get corsCustomPreflightHandler(): CustomPreflightHandler<Req>;

package/lib/config/StaticConfigurationBase.js

@@ -2,8 +2,10 @@ import { DEFAULT_CONFIGURATIONS } from './DefaultConfigurations';
 import { LoggerSeverity, DefaultLogger } from '../logger';
 import { ModuleMode, getScoreApiDomain, getCollectorDomain, isValidEnumValue, EnforcerError, CORE_MODULE_VERSION, } from '../utils';
 export class StaticConfigurationBase {
+    configParams;
+    internalLogger;
     constructor(params, defaultParams) {
-        this.configParams = this.initialize(params, Object.assign(Object.assign({}, DEFAULT_CONFIGURATIONS), defaultParams));
+        this.configParams = this.initialize(params, { ...DEFAULT_CONFIGURATIONS, ...defaultParams });
         this.internalLogger = new DefaultLogger(this.configParams.px_logger_severity);
     }
     initialize(params, defaultParams) {

package/lib/context/DefaultContext.d.ts

@@ -9,7 +9,7 @@ import { ICookieParser, IRequestIdGenerator, VidSource } from '../utils';
 import { IContext, RequestData, RiskApiData, ServerData, TlsData, TokenData } from './interfaces';
 import { ProductData, ProductName } from '../products';
 import { Action } from '../action';
-import { IURLParser } from '../utils/url_parser';
+import { IURLParser } from '../utils';
 export type DefaultContextOptions = {
     cookieParser?: ICookieParser;
     requestIdGenerator: IRequestIdGenerator;

package/lib/context/DefaultContext.js

@@ -4,8 +4,30 @@ import { TokenOrigin, TokenParseResult } from '../risk_token';
 import { RiskApiCallResult } from '../risk_api';
 import { COOKIE_HEADER_NAME, toReadonlyHeaders, USER_AGENT_HEADER_NAME, } from '../http';
 import { StringSplitCookieParser, PXHD_COOKIE_NAME, PXVID_COOKIE_NAME, X_PX_AUTHORIZATION_HEADER_NAME, } from '../utils';
-import { DefaultUrlParser } from '../utils/url_parser';
+import { DefaultUrlParser } from '../impl/url_parser/DefaultUrlParser';
 export class DefaultContext {
+    requestId;
+    tokenOrigin;
+    requestData;
+    tokenData;
+    riskApiData;
+    tlsData;
+    serverData;
+    productData;
+    uuid;
+    vid;
+    vidSource;
+    action;
+    reasons;
+    score;
+    blockAction;
+    pxhd;
+    pxde;
+    pxdeVerified;
+    customParameters;
+    response;
+    config;
+    urlParser;
     constructor(config, request, options) {
         this.config = config;
         this.urlParser = options.urlParser || new DefaultUrlParser();
@@ -40,7 +62,19 @@ export class DefaultContext {
         const readOnlyHeaders = toReadonlyHeaders(headers);
         const userAgent = this.extractUserAgentFromHeader(config, readOnlyHeaders);
         const ip = this.extractIpFromHeader(config, readOnlyHeaders) || request.clientIP;
-        return { url, rawUrl, method, headers: readOnlyHeaders, cookies, ip, userAgent, requestCookieNames, request };
+        const httpVersion = request.httpVersion;
+        return {
+            url,
+            rawUrl,
+            method,
+            headers: readOnlyHeaders,
+            cookies,
+            ip,
+            userAgent,
+            requestCookieNames,
+            request,
+            httpVersion,
+        };
     }
     static getCookies(cookieParser, ...cookieHeaderValues) {
         const cookies = {};
@@ -50,8 +84,7 @@ export class DefaultContext {
         return cookies;
     }
     extractUserAgentFromHeader(config, headers) {
-        var _a;
-        let userAgent = ((_a = headers[USER_AGENT_HEADER_NAME]) === null || _a === void 0 ? void 0 : _a[0]) || '';
+        let userAgent = headers[USER_AGENT_HEADER_NAME]?.[0] || '';
         if (userAgent.length > config.userAgentMaxLength) {
             userAgent = userAgent.substring(0, config.userAgentMaxLength);
         }
@@ -60,8 +93,7 @@ export class DefaultContext {
     extractIpFromHeader(config, headers) {
         let ip;
         config.ipHeaders.some((ipHeader) => {
-            var _a;
-            const headerValue = (_a = headers[ipHeader]) === null || _a === void 0 ? void 0 : _a[0];
+            const headerValue = headers[ipHeader]?.[0];
             if (headerValue) {
                 ip = headerValue;
                 return true;
@@ -73,8 +105,8 @@ export class DefaultContext {
         return request.headers.get(X_PX_AUTHORIZATION_HEADER_NAME) ? TokenOrigin.HEADER : TokenOrigin.COOKIE;
     }
     setCookiesOnContext() {
-        this.vid = this.requestData.cookies[PXVID_COOKIE_NAME] || '';
-        const pxhdCookie = this.requestData.cookies[PXHD_COOKIE_NAME] || '';
+        this.vid = this.requestData.cookies[PXVID_COOKIE_NAME];
+        const pxhdCookie = this.requestData.cookies[PXHD_COOKIE_NAME];
         if (pxhdCookie) {
             this.pxhd = {
                 value: pxhdCookie,

package/lib/context/interfaces/RiskApiData.d.ts

@@ -4,6 +4,10 @@ export type RiskApiData = {
      * The result of the risk API call.
      */
     riskApiCallResult: RiskApiCallResult;
+    /**
+     * The reason for the Risk API call.
+     */
+    s2sCallReason?: string;
     /**
      * An interface representing the risk API response.
      */

package/lib/cors/DefaultCors.js

@@ -1,15 +1,9 @@
-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 { ACCESS_CONTROL_REQUEST_METHOD_HEADER, ORIGIN_HEADER } from './constants';
 import { HttpMethod } from '../http';
 export class DefaultCors {
+    customBlockResponseHeaders;
+    customPreflightHandler;
+    logger;
     constructor(config) {
         this.customBlockResponseHeaders = config.corsCreateCustomBlockResponseHeaders;
         this.customPreflightHandler = config.corsCustomPreflightHandler;
@@ -21,34 +15,30 @@ export class DefaultCors {
             requestData.headers[ORIGIN_HEADER] &&
             requestData.headers[ACCESS_CONTROL_REQUEST_METHOD_HEADER]);
     }
-    runPreflightCustomHandler(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.customPreflightHandler && typeof this.customPreflightHandler === 'function') {
-                try {
-                    return yield this.customPreflightHandler(context.requestData.request.getUnderlyingRequest());
-                }
-                catch (e) {
-                    this.logger.debug(`Exception occurred while executing custom preflight handler: ${e}`);
-                }
+    async runPreflightCustomHandler(context) {
+        if (this.customPreflightHandler && typeof this.customPreflightHandler === 'function') {
+            try {
+                return await this.customPreflightHandler(context.requestData.request.getUnderlyingRequest());
             }
-            return null;
-        });
+            catch (e) {
+                this.logger.debug(`Exception occurred while executing custom preflight handler: ${e}`);
+            }
+        }
+        return null;
     }
     isCorsRequest(context) {
         return !!context.requestData.headers[ORIGIN_HEADER];
     }
-    getCorsBlockHeaders(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.customBlockResponseHeaders && typeof this.customBlockResponseHeaders === 'function') {
-                try {
-                    return yield this.customBlockResponseHeaders(context.requestData.request.getUnderlyingRequest());
-                }
-                catch (e) {
-                    this.logger.debug(`Exception occurred in px_cors_create_custom_block_response_headers custom function: ${e}`);
-                }
+    async getCorsBlockHeaders(context) {
+        if (this.customBlockResponseHeaders && typeof this.customBlockResponseHeaders === 'function') {
+            try {
+                return await this.customBlockResponseHeaders(context.requestData.request.getUnderlyingRequest());
+            }
+            catch (e) {
+                this.logger.debug(`Exception occurred in px_cors_create_custom_block_response_headers custom function: ${e}`);
             }
-            return this.getDefaultCorsHeaders(context);
-        });
+        }
+        return this.getDefaultCorsHeaders(context);
     }
     getDefaultCorsHeaders(context) {
         return {

package/lib/custom_parameters/CustomParametersUtils.js

@@ -1,18 +1,9 @@
-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 var CustomParametersUtils;
 (function (CustomParametersUtils) {
-    CustomParametersUtils.createCustomParameters = (config, context) => __awaiter(this, void 0, void 0, function* () {
+    CustomParametersUtils.createCustomParameters = async (config, context) => {
         if (config.enrichCustomParameters && typeof config.enrichCustomParameters === 'function') {
             try {
-                const parameters = yield config.enrichCustomParameters(config.toParams(), context.requestData.request.getUnderlyingRequest());
+                const parameters = await config.enrichCustomParameters(config.toParams(), context.requestData.request.getUnderlyingRequest());
                 return CustomParametersUtils.normalizeCustomParams(parameters);
             }
             catch (e) {
@@ -20,7 +11,7 @@ export var CustomParametersUtils;
             }
         }
         return null;
-    });
+    };
     CustomParametersUtils.normalizeCustomParams = (customParameters) => {
         const normalizedParams = {};
         if (customParameters && typeof customParameters === 'object') {

package/lib/enforcer/EnforcerBase.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 { DefaultDataEnrichment } from '../pxde';
 import { DefaultTelemetry } from '../telemetry';
 import { DefaultTokenV2Parser, DefaultTokenV3Parser, TokenVersion } from '../risk_token';
@@ -18,6 +9,12 @@ import { HttpActivityClient, HttpBatchedActivityClient } from '../activities';
 import { DefaultGraphQLParser } from '../graphql';
 import { HttpLogServiceClient } from '../logger';
 export class EnforcerBase {
+    config;
+    filterFlow;
+    enforceFlow;
+    postEnforceFlow;
+    endEnforcerFlow;
+    activityClient;
     /**
      * The EnforcerBase constructor.
      * @param config - The enforcer configuration.
@@ -38,20 +35,18 @@ export class EnforcerBase {
      * @param args - The EnforceArgs required to enforce the incoming request.
      * @returns Promise<Res|null> - A Promise resolving to a Res or null depending on the action that should be taken.
      */
-    enforce(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.config.moduleEnabled) {
-                    this.config.logger.debug('module is disabled, will not enforce');
-                    return null;
-                }
-                return yield this.doEnforce(...args);
-            }
-            catch (e) {
-                this.config.logger.error(`caught error in enforce - ${e}`);
+    async enforce(...args) {
+        try {
+            if (!this.config.moduleEnabled) {
+                this.config.logger.debug('module is disabled, will not enforce');
                 return null;
             }
-        });
+            return await this.doEnforce(...args);
+        }
+        catch (e) {
+            this.config.logger.error(`caught error in enforce - ${e}`);
+            return null;
+        }
     }
     /**
      * Performs all enforcer functionality on the incoming request context.
@@ -59,22 +54,20 @@ export class EnforcerBase {
      * @returns Promise<Res|null> -  A Promise resolving to a Res or null depending on the action that should be taken.
      * @protected
      */
-    doEnforce(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const context = yield this.constructContext(...args);
-            let result = yield this.filterFlow.execute(context);
-            if (result.done) {
-                yield this.endEnforcerFlow.execute(context);
-                return result.response ? this.convertToRes(result.response, ...args) : null;
-            }
-            this.preserveContext(context, ...args);
-            result = yield this.enforceFlow.execute(context);
-            if (result.response) {
-                yield this.endEnforcerFlow.execute(context);
-                return this.convertToRes(result.response, ...args);
-            }
-            return null;
-        });
+    async doEnforce(...args) {
+        const context = await this.constructContext(...args);
+        let result = await this.filterFlow.execute(context);
+        if (result.done) {
+            await this.endEnforcerFlow.execute(context);
+            return result.response ? this.convertToRes(result.response, ...args) : null;
+        }
+        this.preserveContext(context, ...args);
+        result = await this.enforceFlow.execute(context);
+        if (result.done) {
+            await this.endEnforcerFlow.execute(context);
+            return result.response ? this.convertToRes(result.response, ...args) : null;
+        }
+        return null;
     }
     /**
      * Performs all required functionality after an origin response has been received.
@@ -82,28 +75,24 @@ export class EnforcerBase {
      * @returns Promise<void> - The response parameter will be modified as needed
      * @protected
      */
-    postEnforce(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const context = this.retrieveContext(...args);
-                if (context) {
-                    context.response = yield this.convertToOutgoingResponse(...args);
-                    yield this.postEnforceFlow.execute(context);
-                }
-                yield this.endEnforcerFlow.execute(context);
-            }
-            catch (e) {
-                this.config.logger.error(`caught error in post enforce - ${e}`);
-            }
-        });
-    }
-    sendAdditionalS2SActivity(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async postEnforce(...args) {
+        try {
             const context = this.retrieveContext(...args);
             if (context) {
-                yield this.activityClient.sendActivities(context);
+                context.response = await this.convertToOutgoingResponse(...args);
+                await this.postEnforceFlow.execute(context);
+                await this.endEnforcerFlow.execute(context);
             }
-        });
+        }
+        catch (e) {
+            this.config.logger.error(`caught error in post enforce - ${e}`);
+        }
+    }
+    async sendAdditionalS2SActivity(...args) {
+        const context = this.retrieveContext(...args);
+        if (context) {
+            await this.activityClient.sendActivities(context);
+        }
     }
     /**
      * Returns the components needed to initialize the enforcer according to the provided options. If no
@@ -149,20 +138,20 @@ export class EnforcerBase {
             logServiceClient,
         };
         const products = this.initializeProducts(config, options.products, base64Utils, hashUtils, ipRangeChecker);
-        return Object.assign({ products }, allOptions);
+        return { products, ...allOptions };
     }
     initializeProducts(config, products, base64Utils, hashUtils, ipRangeChecker) {
-        const botDefender = (products === null || products === void 0 ? void 0 : products.bd) || new BotDefender(config, { base64Utils, ipRangeChecker });
-        const accountDefender = (products === null || products === void 0 ? void 0 : products.ad) || new AccountDefender(config, { base64Utils });
+        const botDefender = products?.bd || new BotDefender(config, { base64Utils, ipRangeChecker });
+        const accountDefender = products?.ad || new AccountDefender(config, { base64Utils });
         const credentialIntelligence = config.ciEnabled
-            ? (products === null || products === void 0 ? void 0 : products.ci) || new CredentialIntelligence(config, hashUtils)
+            ? products?.ci || new CredentialIntelligence(config, hashUtils)
             : null;
         return {
             [ProductName.BOT_DEFENDER]: botDefender,
             [ProductName.ACCOUNT_DEFENDER]: accountDefender,
-            [ProductName.CODE_DEFENDER]: products === null || products === void 0 ? void 0 : products.cd,
+            [ProductName.CODE_DEFENDER]: products?.cd,
             [ProductName.CREDENTIAL_INTELLIGENCE]: credentialIntelligence,
-            [ProductName.HYPE_SALE_CHALLENGE]: products === null || products === void 0 ? void 0 : products.hsc,
+            [ProductName.HYPE_SALE_CHALLENGE]: products?.hsc,
         };
     }
 }