perimeterx-js-core 0.7.0 → 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

@@ -73,8 +73,9 @@ export type ConfigurationParams<Req, Res> = {
     px_sensitive_graphql_operation_types?: Array<'query' | 'mutation' | 'subscription' | GraphQLOperationType>;
     px_cors_support_enabled?: boolean;
     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/DefaultConfigurations.js

@@ -114,4 +114,5 @@ export const DEFAULT_CONFIGURATIONS = {
     px_cors_custom_preflight_handler: null,
     px_cors_preflight_request_filter_enabled: false,
     px_cors_create_custom_block_response_headers: null,
+    px_logger_auth_token: '',
 };

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.
      */
@@ -301,6 +301,10 @@ export interface IConfiguration<Req, Res, ParamsType extends ConfigurationParams
      * The default login successful custom callback to use if none is defined for an endpoint.
      */
     readonly ciDefaultLoginSuccessfulCustomCallback: CustomLoginSuccessfulCallback<Res>;
+    /**
+     * The authentication token for the logging service.
+     */
+    readonly loggerAuthToken: string;
     /**
      * Returns an object representation of the current configuration.
      */

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>;
@@ -76,6 +76,7 @@ export declare abstract class StaticConfigurationBase<Req, Res, ParamsType exten
     get jwtHeaderName(): string;
     get jwtHeaderUserIdFieldName(): string;
     get ciEnabled(): boolean;
+    get loggerAuthToken(): string;
     get ciEndpoints(): CredentialEndpointConfiguration<Req, Res>[];
     get ciCompromisedCredentialsHeaderName(): string;
     get ciSendRawUsernameOnAdditionalS2SActivity(): boolean;

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) {
@@ -236,6 +238,9 @@ export class StaticConfigurationBase {
     get ciEnabled() {
         return this.configParams.px_login_credentials_extraction_enabled;
     }
+    get loggerAuthToken() {
+        return this.configParams.px_logger_auth_token;
+    }
     get ciEndpoints() {
         return this.configParams.px_login_credentials_extraction;
     }

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.d.ts

@@ -13,6 +13,7 @@ export declare abstract class EnforcerBase<TokenV extends TokenVersion, Req, Res
     protected readonly filterFlow: IPhase<Req, Res>;
     protected readonly enforceFlow: IPhase<Req, Res>;
     protected readonly postEnforceFlow: IPhase<Req, Res>;
+    protected readonly endEnforcerFlow: IPhase<Req, Res>;
     protected readonly activityClient: IActivityClient<Req, Res>;
     /**
      * Constructs the concrete request context given the provided EnforceArgs.
@@ -42,7 +43,7 @@ export declare abstract class EnforcerBase<TokenV extends TokenVersion, Req, Res
      * @returns Promise<Res> - A Promise resolving to Res.
      * @protected
      */
-    protected abstract convertToRes(response: IMinimalResponse): Promise<Res>;
+    protected abstract convertToRes(response: IMinimalResponse, ...args: EnforceArgs): Promise<Res>;
     /**
      * Converts the Res object into the IOutgoingResponse interface.
      * @param args - PostEnforceArgs