perimeterx-js-core 0.25.0 → 0.26.0

package/lib/esm/action/utils.js

@@ -1,9 +1,19 @@
 import { Action } from './Action.js';
 import { PRODUCT_PRIORITY_ORDER } from '../products/index.js';
 import { ACTION_PRIORITY_ORDER } from './ActionPriorityOrder.js';
+/**
+ * Determines the final decision from the context.
+ * @param context - The request context.
+ * @returns Decision - The final action that should be taken and the associated products and reasons responsible for the decision.
+ */
 export const getDecisionFromContext = (context) => {
     return getDecisionFromActions(getProductActions(context));
 };
+/**
+ * Determines all product recommended actions from the context.
+ * @param context - The request context.
+ * @returns ProductAction[] - An array of objects, representing the recommended action and reason of all relevant products.
+ */
 export const getProductActions = (context) => {
     return Object.entries(context.productData)
         .filter(([_, data]) => data?.action != null && data?.reason != null)
@@ -13,6 +23,11 @@ export const getProductActions = (context) => {
         productName: productName,
     }));
 };
+/**
+ * Reduces a list of ProductActions to a single Decision, taking into consideration the ACTION_PRIORITY_ORDER.
+ * @param productActions - All possible actions from all products.
+ * @returns Decision - The final action that should be taken and the associated products and reasons responsible for the decision.
+ */
 export const getDecisionFromActions = (productActions) => {
     return createDecision(reduce(productActions));
 };
@@ -33,6 +48,11 @@ const createDecision = (tally) => {
     }
     return { action: Action.PASS_REQUEST, reasons: {} };
 };
+/**
+ * Provided a mapping of product names to reasons, returns the reason associated with the highest priority product in the mapping.
+ * @param reasons - An object mapping any product names to their associated reasons.
+ * @returns string - The reason for the highest priority product, or 'unknown_reason' if none is found.
+ */
 export const getReasonForHighestPriorityProduct = (reasons) => {
     for (let productName of PRODUCT_PRIORITY_ORDER) {
         const reason = reasons[productName];

package/lib/esm/activities/HttpActivityClient.js

@@ -4,16 +4,33 @@ import { getAuthorizationHeader } from '../utils/index.js';
 import { ActivityType } from './ActivityType.js';
 import { createAsyncActivity } from './utils.js';
 import { ACTIVITIES_ENDPOINT } from './constants.js';
+/**
+ * The HttpActivityClient is responsible for sending async activities to the backend via HTTP.
+ */
 export class HttpActivityClient {
     config;
     httpClient;
+    /**
+     * Creates an instance of HttpActivityClient.
+     * @param config
+     * @param httpClient
+     */
     constructor(config, httpClient) {
         this.config = config;
         this.httpClient = httpClient;
     }
+    /**
+     * Creates and sends all necessary async activities to the backend.
+     * @param context - The context containing the request (and possibly response).
+     * @returns {Promise<boolean>} - A boolean indicating if the activities were sent successfully.
+     */
     async sendActivities(context) {
         try {
             const activities = this.createActivities(context);
+            if (!activities || activities.length === 0) {
+                context.logger.debug('no activities to send');
+                return true;
+            }
             return await this.postActivities(activities, context.logger);
         }
         catch (e) {
@@ -21,6 +38,12 @@ export class HttpActivityClient {
             return false;
         }
     }
+    /**
+     * Creates all async activities (block, page_requested, additional_s2s) that should be sent based on the context.
+     * @param context - The context containing the request (and possibly response).
+     * @returns {AsyncActivity[]} - An array of async activities to be sent.
+     * @protected
+     */
     createActivities(context) {
         const activities = [];
         if (this.shouldCreateBlockActivity(context)) {
@@ -34,28 +57,58 @@ export class HttpActivityClient {
         }
         return activities.map(this.finalizeActivity);
     }
+    /**
+     * Whether to create a block activity based on the context.
+     * @param context
+     * @protected
+     */
     shouldCreateBlockActivity(context) {
         return context.action === Action.BLOCK || context.action === Action.SIMULATED_BLOCK;
     }
+    /**
+     * Whether to create a page_requested activity based on the context.
+     * @param context
+     * @protected
+     */
     shouldCreatePageRequestedActivity(context) {
         return context.action === Action.PASS_REQUEST;
     }
+    /**
+     * Whether to create an additional_s2s activity based on the context.
+     * @param context
+     * @protected
+     */
     shouldCreateAdditionalS2SActivity(context) {
         return (this.shouldCreatePageRequestedActivity(context) &&
             !!context.productData.ci &&
             this.config.ciAutomaticAdditionalS2SEnabled);
     }
+    /**
+     * Creates a block activity based on the context.
+     * @param context
+     * @protected
+     */
     createBlockActivity(context) {
         return createAsyncActivity(ActivityType.BLOCK, this.config, context);
     }
+    /**
+     * Creates a page_requested activity based on the context.
+     * @param context
+     * @protected
+     */
     createPageRequestedActivity(context) {
         return createAsyncActivity(ActivityType.PAGE_REQUESTED, this.config, context);
     }
+    /**
+     * Creates an additional_s2s activity based on the context.
+     * @param context
+     * @protected
+     */
     createAdditionalS2SActivity(context) {
         return createAsyncActivity(ActivityType.ADDITIONAL_S2S, this.config, context);
     }
     /**
-     * Allows for expansions or alterations to the async activity if needed.
+     * Allows for expansions or alterations to an async activity if needed. This applies to all created async activities.
      * @param activity
      * @returns AsyncActivity
      * @protected
@@ -63,6 +116,13 @@ export class HttpActivityClient {
     finalizeActivity(activity) {
         return activity;
     }
+    /**
+     * Sends the async activities to the backend.
+     * @param activities - The activities to be sent.
+     * @param logger - The logger instance for logging.
+     * @returns {Promise<boolean>} - A boolean indicating if the activities were sent successfully.
+     * @protected
+     */
     async postActivities(activities, logger) {
         const url = `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`;
         const method = HttpMethod.POST;

package/lib/esm/activities/HttpBatchedActivityClient.js

@@ -1,4 +1,11 @@
 import { HttpActivityClient } from './HttpActivityClient.js';
+/**
+ * The HttpBatchedActivityClient is responsible for sending async activities to the backend via HTTP in batches.
+ * It extends the HttpActivityClient class and adds functionality for batching activities.
+ *
+ * This class uses setTimeout and clearTimeout for managing the timeout for sending activities. It also exposes the stop()
+ * method to stop the timer and prevent further activity sending, which should be called on shutdown.
+ */
 export class HttpBatchedActivityClient extends HttpActivityClient {
     batchSize;
     timeoutMs;

package/lib/esm/activities/utils.js

@@ -1,8 +1,15 @@
-import { EnforcerError, ModuleMode, removeSensitiveHeaders, transferExistingProperties } from '../utils/index.js';
+import { EnforcerError, ModuleMode, removeSensitiveHeaders } from '../utils/index.js';
 import { ProductName } from '../products/index.js';
 import { Action, getReasonForHighestPriorityProduct } from '../action/index.js';
 import { ActivityType } from './ActivityType.js';
 import { TokenParseResult } from '../risk_token/index.js';
+/**
+ * Creates an async activity object based on the provided parameters.
+ * @param activityType - The activity type to create.
+ * @param config - The enforcer configuration.
+ * @param context - The request context.
+ * @returns {AsyncActivity} - The complete async activity payload.
+ */
 export const createAsyncActivity = (activityType, config, context) => {
     return {
         type: activityType,
@@ -18,6 +25,13 @@ export const createAsyncActivity = (activityType, config, context) => {
         details: createActivityDetails(activityType, config, context),
     };
 };
+/**
+ * Creates activity details based on the provided parameters.
+ * @param activityType - The activity type to create.
+ * @param config - The enforcer configuration.
+ * @param context - The request context.
+ * @returns {AsyncActivityDetails} - The activity details.
+ */
 export const createActivityDetails = (activityType, config, context) => {
     const commonActivityDetails = createCommonActivityDetails(config, context);
     const commonAsyncActivityDetails = createAsyncActivityCommonDetails(context);
@@ -60,13 +74,21 @@ export const createCommonActivityDetails = (config, context) => {
     return details;
 };
 export const addRootContextDataToDetails = (details, context) => {
-    transferExistingProperties(context, details, {
-        requestId: 'request_id',
-        tokenOrigin: 'cookie_origin',
-        vidSource: 'enforcer_vid_source',
-        graphqlData: 'graphql_operations',
-        enforcerStartTime: 'enforcer_start_time',
-    });
+    if (context.requestId) {
+        details.request_id = context.requestId;
+    }
+    if (context.tokenOrigin) {
+        details.cookie_origin = context.tokenOrigin;
+    }
+    if (context.vidSource) {
+        details.enforcer_vid_source = context.vidSource;
+    }
+    if (context.graphqlData) {
+        details.graphql_operations = context.graphqlData;
+    }
+    if (context.enforcerStartTime) {
+        details.enforcer_start_time = context.enforcerStartTime;
+    }
     if (context.usedCookieSecret) {
         details.used_cookie_secret = redactCookieSecret(context.usedCookieSecret);
     }
@@ -75,10 +97,12 @@ export function redactCookieSecret(secret) {
     return '***'.concat(secret.substring(secret.length - 3, secret.length));
 }
 export const addConfigDataToDetails = (details, config) => {
-    transferExistingProperties(config, details, {
-        remoteConfigId: 'remote_config_id',
-        remoteConfigVersion: 'remote_config_version',
-    });
+    if (config.remoteConfigId) {
+        details.remote_config_id = config.remoteConfigId;
+    }
+    if (config.remoteConfigVersion) {
+        details.remote_config_version = config.remoteConfigVersion;
+    }
 };
 export const addCustomParametersToDetails = (details, customParameters) => {
     if (customParameters) {
@@ -86,44 +110,78 @@ export const addCustomParametersToDetails = (details, customParameters) => {
     }
 };
 export const addProductDataToDetails = (details, productData) => {
-    transferExistingProperties(productData.ad, details, {
-        appUserId: 'app_user_id',
-        additionalFields: 'jwt_additional_fields',
-        crossTabSession: 'cross_tab_session',
-    });
-    transferExistingProperties(productData.ci, details, {
-        hashedUsername: 'user',
-        hashedPassword: 'pass',
-        ciVersion: 'ci_version',
-        ssoStep: 'sso_step',
-    });
-    transferExistingProperties(productData.hsc, details, {
-        isTokenHscApproved: 'cpa',
-    });
+    if (productData.ad) {
+        if (productData.ad.appUserId) {
+            details.app_user_id = productData.ad.appUserId;
+        }
+        if (productData.ad.additionalFields) {
+            details.jwt_additional_fields = productData.ad.additionalFields;
+        }
+        if (productData.ad.crossTabSession) {
+            details.cross_tab_session = productData.ad.crossTabSession;
+        }
+    }
+    if (productData.ci) {
+        if (productData.ci.hashedUsername) {
+            details.user = productData.ci.hashedUsername;
+        }
+        if (productData.ci.hashedPassword) {
+            details.pass = productData.ci.hashedPassword;
+        }
+        if (productData.ci.ciVersion) {
+            details.ci_version = productData.ci.ciVersion;
+        }
+        if (productData.ci.ssoStep) {
+            details.sso_step = productData.ci.ssoStep;
+        }
+    }
+    if (productData.hsc) {
+        if (typeof productData.hsc.isTokenHscApproved === 'boolean') {
+            details.cpa = productData.hsc.isTokenHscApproved;
+        }
+    }
 };
 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',
-    });
+    if (tlsData.tlsCipher) {
+        details.tls_cipher = tlsData.tlsCipher;
+    }
+    if (tlsData.tlsCiphersSha) {
+        details.tls_ciphers_sha = tlsData.tlsCiphersSha;
+    }
+    if (tlsData.tlsExtensionSha) {
+        details.tls_extension_sha = tlsData.tlsExtensionSha;
+    }
+    if (tlsData.tlsPreferredCiphers) {
+        details.tls_preferred_ciphers = tlsData.tlsPreferredCiphers;
+    }
+    if (tlsData.tlsJa3Fingerprint) {
+        details.tls_ja3_fingerprint = tlsData.tlsJa3Fingerprint;
+    }
+    if (tlsData.tlsProtocol) {
+        details.tls_protocol = tlsData.tlsProtocol;
+    }
+    if (tlsData.tlsServer) {
+        details.tls_server = tlsData.tlsServer;
+    }
 };
 export const addServerDataToDetails = (details, serverData) => {
-    transferExistingProperties(serverData, details, {
-        region: 'server_info_region',
-        datacenter: 'server_info_datacenter',
-    });
+    if (serverData.datacenter) {
+        details.server_info_datacenter = serverData.datacenter;
+    }
+    if (serverData.region) {
+        details.server_info_region = serverData.region;
+    }
 };
 export const addRequestDataToDetails = (details, requestData) => {
-    transferExistingProperties(requestData, details, {
-        httpVersion: 'http_version',
-        method: 'http_method',
-        requestCookieNames: 'request_cookie_names',
-    });
+    if (requestData.httpVersion) {
+        details.http_version = requestData.httpVersion;
+    }
+    if (requestData.method) {
+        details.http_method = requestData.method;
+    }
+    if (requestData.requestCookieNames) {
+        details.request_cookie_names = requestData.requestCookieNames.concat();
+    }
     if (requestData.isUrlDifferentFromRawUrl) {
         details.raw_url = requestData.rawUrl;
     }
@@ -139,10 +197,12 @@ export const addTokenDataToDetails = (details, { token, mobileData }) => {
         }
     }
     if (mobileData) {
-        transferExistingProperties(mobileData, details, {
-            originalToken: 'original_token',
-            decodedOriginalToken: 'px_decoded_original_token',
-        });
+        if (mobileData.originalToken) {
+            details.original_token = mobileData.originalToken.tokenString;
+        }
+        if (mobileData.decodedOriginalToken) {
+            details.px_decoded_original_token = mobileData.decodedOriginalToken;
+        }
         if (mobileData.originalTokenParseResult === TokenParseResult.DECRYPTION_FAILED) {
             details.original_token_error = 'cookie_decryption_failed';
         }
@@ -152,11 +212,15 @@ export const addTokenDataToDetails = (details, { token, mobileData }) => {
     }
 };
 export const addRiskApiDataToAsyncActivityCommonDetails = (details, context) => {
-    transferExistingProperties(context.riskApiData, details, {
-        riskRtt: 'risk_rtt',
-        s2sCallReason: 's2s_call_reason',
-        riskStartTime: 'risk_start_time',
-    });
+    if (context.riskApiData.riskRtt) {
+        details.risk_rtt = context.riskApiData.riskRtt;
+    }
+    if (context.riskApiData.s2sCallReason) {
+        details.s2s_call_reason = context.riskApiData.s2sCallReason;
+    }
+    if (context.riskApiData.riskStartTime) {
+        details.risk_start_time = context.riskApiData.riskStartTime;
+    }
     if (context.riskApiData.riskResponse?.additionalRiskInfo) {
         details.additional_risk_info = context.riskApiData.riskResponse.additionalRiskInfo;
     }
@@ -165,21 +229,23 @@ export const addRiskApiDataToAsyncActivityCommonDetails = (details, context) =>
     }
 };
 export const addResponseDataToAsyncActivityCommonDetails = (details, context) => {
-    if (context.action !== Action.BLOCK) {
-        transferExistingProperties(context.response, details, {
-            status: 'http_status_code',
-        });
+    if (context.action !== Action.BLOCK && context.response?.status) {
+        details.http_status_code = context.response.status;
     }
 };
 export const createPageRequestedActivityDetails = (context) => {
     const details = {
         pass_reason: getReasonForHighestPriorityProduct(context.reasons),
     };
-    transferExistingProperties(context.riskApiData, details, {
-        errorReason: 's2s_error_reason',
-        errorHttpStatus: 's2s_error_http_status',
-        errorMessage: 'error_message',
-    });
+    if (context.riskApiData.errorReason) {
+        details.s2s_error_reason = context.riskApiData.errorReason;
+    }
+    if (context.riskApiData.errorHttpStatus) {
+        details.s2s_error_http_status = context.riskApiData.errorHttpStatus;
+    }
+    if (context.riskApiData.errorMessage) {
+        details.error_message = context.riskApiData.errorMessage;
+    }
     return details;
 };
 export const createBlockActivityDetails = (context) => {
@@ -187,7 +253,6 @@ export const createBlockActivityDetails = (context) => {
         block_reason: getReasonForHighestPriorityProduct(context.reasons),
         simulated_block: context.action === Action.SIMULATED_BLOCK,
         block_action: context.blockAction,
-        // @ts-ignore
         block_score: context.score,
     };
 };

package/lib/esm/additional_activity_handler/AdditionalActivityHandlerUtils.js

@@ -1,5 +1,11 @@
 export var AdditionalActivityHandlerUtils;
 (function (AdditionalActivityHandlerUtils) {
+    /**
+     * Invokes the additional activity handler if it is defined in the configuration.
+     * @param config - The enforcer configuration.
+     * @param context - The request context.
+     * @returns {Promise<void>} - A promise that resolves when the additional activity handler is complete.
+     */
     AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler = async (config, context) => {
         if (config.additionalActivityHandler && typeof config.additionalActivityHandler === 'function') {
             try {

package/lib/esm/blocker/BlockerBase.js

@@ -1,11 +1,25 @@
 import { CONTENT_TYPE_HEADER_NAME, MinimalResponseImpl } from '../http/index.js';
+/**
+ * Base class for creating a block response.
+ */
 export class BlockerBase {
     statusCode;
     contentType;
+    /**
+     * Creates a new instance of BlockerBase.
+     * @param contentType - The Content-Type header to be included in the HTTP block response.
+     * @param statusCode - The status code of the HTTP block response.
+     * @protected
+     */
     constructor(contentType, statusCode = 403) {
         this.contentType = contentType;
         this.statusCode = statusCode;
     }
+    /**
+     * Creates the complete HTTP block response based on the given context.
+     * @param context - The request context.
+     * @returns {IMinimalResponse} - The HTTP block response.
+     */
     createBlockResponse(context) {
         const status = this.statusCode;
         const headers = this.createHeaders();

package/lib/esm/blocker/JsonBlockerBase.js

@@ -1,5 +1,10 @@
 import { BlockerBase } from './BlockerBase.js';
 import { ACCEPT_HEADER_NAME, ContentType } from '../http/index.js';
+/**
+ * Base class for creating a block response with JSON payload.
+ *
+ * The generic argument JsonPayloadT is the specific structure of the JSON payload to be returned.
+ */
 export class JsonBlockerBase extends BlockerBase {
     constructor() {
         super(ContentType.APPLICATION_JSON);

package/lib/esm/blocker/utils.js

@@ -1,4 +1,10 @@
 import { FirstPartySuffix, getMostCustomizedFirstPartyPath } from '../products/index.js';
+/**
+ * Renders the HTML template with the provided block data.
+ * @param htmlTemplate - The HTML template to be rendered. Placeholders are indicated with {{key_name}} where the key_name should be keyof BlockData.
+ * @param blockData - The block data to be used for rendering. The keys in the object should match the placeholders in the template.
+ * @returns {string} - The final HTML string. If no block data is provided, the original template is returned unchanged.
+ */
 export const renderHtml = (htmlTemplate, blockData) => {
     if (!blockData) {
         return htmlTemplate;
@@ -10,6 +16,13 @@ export const renderHtml = (htmlTemplate, blockData) => {
     });
     return htmlTemplate;
 };
+/**
+ * Creates the block data object to be used when creating a block response.
+ * @param config - The enforcer configuration.
+ * @param context - The request context.
+ * @param base64Utils - The base64 utility functions.
+ * @returns {BlockData} - The block data object.
+ */
 export const createBlockData = (config, context, base64Utils) => {
     const captchaScriptSuffix = '/captcha.js';
     const b64EncodedUrl = config.enableBlockedUrlOnCaptchaBlockPage

package/lib/esm/config/ConfigurationBase.js

@@ -3,6 +3,9 @@ import { DefaultLogger, LoggerSeverity } from '../logger/index.js';
 import { CORE_MODULE_VERSION, EnforcerConfigurationError, getCollectorDomain, getScoreApiDomain, isNullOrUndefined, isValidEnumValue, ModuleMode, } from '../utils/index.js';
 import { RemoteConfigUtils } from './remote_config/index.js';
 import { TokenVersion } from '../risk_token/index.js';
+/**
+ * Base class for the enforcer configuration.
+ */
 export class ConfigurationBase {
     configParams;
     staticConfigParams;
@@ -11,6 +14,13 @@ export class ConfigurationBase {
     removedParams;
     // Logger is initialized at `createActiveConfiguration`
     internalLogger;
+    /**
+     * Creates an instance of the configuration base class.
+     * @param params - The configuration parameters as provided by the customer.
+     * @param defaultParams - Default parameters for added configurations or any default core configurations that should be overridden.
+     * @param removedParams - A map of all removed (unsupported) configuration parameters set to undefined. This parameter can be generated automatically by your IDE.
+     * @protected
+     */
     constructor(params, defaultParams, removedParams) {
         this.defaultConfigParams = { ...defaultConfigurationParams(), ...defaultParams };
         this.configParams = this.createActiveConfiguration(params, this.defaultConfigParams);
@@ -374,4 +384,7 @@ export class ConfigurationBase {
     get enableBlockedUrlOnCaptchaBlockPage() {
         return true;
     }
+    get isPostEnforceEnabled() {
+        return true;
+    }
 }

package/lib/esm/context/DefaultContext.js

@@ -6,6 +6,10 @@ import { COOKIE_HEADER_NAME, toReadonlyHeaders, USER_AGENT_HEADER_NAME, } from '
 import { isValidUuid, PXHD_COOKIE_NAME, PXVID_COOKIE_NAME, StringSplitCookieParser, X_PX_AUTHORIZATION_HEADER_NAME, } from '../utils/index.js';
 import { Action } from '../action/index.js';
 import { DefaultLogger, X_PX_ENFORCER_LOG_HEADER } from '../logger/index.js';
+/**
+ * The default implementation of the request context which uses the incoming HTTP request and enforcer configuration
+ * to populate the context with relevant data.
+ */
 export class DefaultContext {
     requestId;
     tokenOrigin;

package/lib/esm/context/SerializedContext.js

@@ -1,6 +1,11 @@
 import { DefaultLogger } from '../logger/index.js';
 import { SerializedToken } from '../risk_token/index.js';
 import { SerializedRiskResponse } from '../risk_api/index.js';
+/**
+ * Implements the `IContext` interface based an already serialized `ContextJson`. This class does not extract data from the
+ * incoming request, but rather uses already-extracted data from the `ContextJson` (likely returned from the `DefaultContext.toJSON()`
+ * function) and fills in the gaps using the other parameters.
+ */
 export class SerializedContext {
     isMobile;
     remoteConfigUpdateData;

package/lib/esm/enforcer/EnforcerBase.js

@@ -1,5 +1,8 @@
-import { EndEnforcerFlow, EnforceFlow, FilterFlow, PostEnforceFlow } from '../phase/index.js';
+import { EndEnforcerFlow, EnforceFlow, FilterFlow, PostEnforceFlow } from '../flow/index.js';
 import { createEnforcerInitializationBlock } from './utils.js';
+/**
+ * The base class for fundamental enforcer logic.
+ */
 export class EnforcerBase {
     config;
     filterFlow;
@@ -27,15 +30,47 @@ export class EnforcerBase {
             this.config.logger.debug('HUMAN enforcer is disabled, will not enforce');
         }
     }
+    /**
+     * Creates the filter flow for the enforcer. The filter flow is responsible for filtering out requests that should not undergo the usual enforcement flow.
+     * For example, first party, filtered, CORS preflight, and telemetry requests are filtered out.
+     * @param config - The configuration object.
+     * @param initializationBlock - All entities necessary for the enforcer to function.
+     * @protected
+     * @returns - The filter flow for the enforcer.
+     */
     createFilterFlow(config, initializationBlock) {
         return new FilterFlow(config, initializationBlock);
     }
+    /**
+     * Creates the post enforce flow for the enforcer. The post enforce flow is responsible for any logic that requires the origin response in the case of passed requests.
+     * For example, enriching the context with response data (status, login successful information) and modifying the origin response (snippet injection, PXHD) are part of the post enforce flow.
+     * @param config - The configuration object.
+     * @param initializationBlock - All entities necessary for the enforcer to function.
+     * @protected
+     * @returns - The post enforce flow for the enforcer or null if post enforce is not enabled.
+     */
     createPostEnforceFlow(config, initializationBlock) {
-        return new PostEnforceFlow(config, initializationBlock);
+        return this.config.isPostEnforceEnabled ? new PostEnforceFlow(config, initializationBlock) : null;
     }
+    /**
+     * Creates the enforce flow for the enforcer. The enforce flow is responsible for the core functionality of HUMAN enforcement.
+     * For example, parsing HUMAN cookies, performing Risk API, invoking the additional activity handler, and returning a block response are part of the enforce flow.
+     * @param config - The configuration object.
+     * @param initializationBlock - All entities necessary for the enforcer to function.
+     * @protected
+     * @returns - The enforce flow for the enforcer.
+     */
     createEnforceFlow(config, initializationBlock) {
         return new EnforceFlow(config, initializationBlock);
     }
+    /**
+     * Creates the end enforce flow for the enforcer. The end enforce flow is responsible for all actions that must be done after every incoming request.
+     * For example, sending the async activities, sending the telemetry activity, or updating the remote config, sending and clearing the enforcer logs, are parts of the end enforce flow.
+     * @param config - The configuration object.
+     * @param initializationBlock - All entities necessary for the enforcer to function.
+     * @protected
+     * @returns - The end enforce flow for the enforcer.
+     */
     createEndEnforcerFlow(config, initializationBlock) {
         return new EndEnforcerFlow(config, initializationBlock);
     }
@@ -72,12 +107,14 @@ export class EnforcerBase {
             await this.endEnforcerFlow.execute(context);
             return result.response ? this.convertToRes(result.response, ...args) : null;
         }
-        await this.preserveContext(context, ...args);
         result = await this.enforceFlow.execute(context);
-        if (result.done) {
+        if (result.done || !this.config.isPostEnforceEnabled) {
             await this.endEnforcerFlow.execute(context);
             return result.response ? this.convertToRes(result.response, ...args) : null;
         }
+        if (this.config.isPostEnforceEnabled) {
+            await this.preserveContext(context, ...args);
+        }
         return null;
     }
     /**
@@ -88,13 +125,13 @@ export class EnforcerBase {
     async postEnforce(...args) {
         let context;
         try {
-            if (!this.config.moduleEnabled) {
+            if (!this.config.moduleEnabled || !this.config.isPostEnforceEnabled) {
                 return;
             }
             context = this.retrieveContext(...args);
             if (context) {
                 context.response = await this.convertToOutgoingResponse(...args);
-                await this.postEnforceFlow.execute(context);
+                await this.postEnforceFlow?.execute(context);
                 await this.endEnforcerFlow.execute(context);
             }
         }