perimeterx-js-core 0.24.4 → 0.26.0

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,14 +3,24 @@ 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;
-    remoteConfigParams;
+    remoteConfigData;
     defaultConfigParams;
     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);
@@ -75,15 +85,15 @@ export class ConfigurationBase {
         }
     }
     createInternalLogger(params) {
-        return new DefaultLogger(params.px_logger_severity, false);
+        return new DefaultLogger(params.px_logger_severity, false, this.logger?.getLogs());
     }
-    addRemoteConfig(remoteConfigParams) {
-        this.remoteConfigParams = remoteConfigParams;
-        const mergedParams = {
+    setRemoteConfigData(remoteConfigData) {
+        this.remoteConfigData = remoteConfigData;
+        const params = {
             ...this.staticConfigParams,
-            ...RemoteConfigUtils.prepareRemoteConfigParams(remoteConfigParams, this.logger),
+            ...RemoteConfigUtils.prepareRemoteConfigParams(remoteConfigData, this.logger),
         };
-        this.configParams = this.createActiveConfiguration(mergedParams, this.defaultConfigParams);
+        this.configParams = this.createActiveConfiguration(params, this.defaultConfigParams);
     }
     getActiveConfig() {
         const activeConfig = Object.assign({}, this.configParams);
@@ -97,7 +107,9 @@ export class ConfigurationBase {
         return Object.assign({}, this.staticConfigParams);
     }
     getRemoteConfig() {
-        return Object.assign({}, this.remoteConfigParams);
+        return this.remoteConfigData
+            ? RemoteConfigUtils.prepareRemoteConfigParams(this.remoteConfigData, this.logger)
+            : {};
     }
     get moduleVersion() {
         return `${this.getModuleVersion()} (${CORE_MODULE_VERSION})`;
@@ -372,4 +384,7 @@ export class ConfigurationBase {
     get enableBlockedUrlOnCaptchaBlockPage() {
         return true;
     }
+    get isPostEnforceEnabled() {
+        return true;
+    }
 }

package/lib/esm/config/index.js

@@ -1,6 +1,5 @@
 export * from './IConfiguration.js';
 export * from './ConfigurationBase.js';
-export * from './ConfigurationBuilderBase.js';
 export * from './CustomRequestFunction.js';
 export * from './remote_config/index.js';
 export * from './params/index.js';

package/lib/esm/config/remote_config/RemoteConfigUtils.js

@@ -6,8 +6,17 @@ export var RemoteConfigUtils;
     RemoteConfigUtils.isRemoteConfigUpdateRequest = (request) => request.method === HttpMethod.POST &&
         request.headers.get(PUSH_DATA_FEATURE_HEADER_NAME) === REMOTE_CONFIG_PUSH_DATA_FEATURE_NAME &&
         !!request.headers.get(PUSH_DATA_HMAC_HEADER_NAME);
-    RemoteConfigUtils.prepareRemoteConfigParams = (remoteConfigParams, logger) => {
-        const remoteConfig = Object.assign({}, remoteConfigParams);
+    RemoteConfigUtils.prepareRemoteConfigParams = ({ version, configValue }, logger) => {
+        const remoteConfig = {
+            px_remote_config_version: version,
+            px_remote_config_enabled: configValue.px_remote_config_enabled,
+        };
+        if (!configValue.px_remote_config_enabled) {
+            // returning only the version and the fact that remote config is disabled
+            // so we can report the version on async activities without merging the rest of the remote configs
+            return remoteConfig;
+        }
+        Object.assign(remoteConfig, configValue);
         // Remote config receives strings and regexes in separate fields (px_sensitive_routes, px_sensitive_routes_regex)
         // Before initializing a new active configuration, we merge the two into the more generic field (px_sensitive_routes)
         CONFIG_KEYS_WITH_REGEX_EQUIVALENT_IN_REMOTE_CONFIG.forEach((k) => {

package/lib/esm/config/remote_config/index.js

@@ -2,6 +2,6 @@ export * from './constants.js';
 export * from './model/index.js';
 export * from './service_client/index.js';
 export * from './storage_client/index.js';
-export * from './DefaultRemoteConfigUpdater.js';
-export * from './IRemoteConfigUpdater.js';
+export * from './manager/index.js';
+export * from './update_parser/index.js';
 export * from './RemoteConfigUtils.js';

package/lib/esm/config/remote_config/manager/DefaultRemoteConfigManager.js

@@ -0,0 +1,87 @@
+import { sleep } from '../../../utils/index.js';
+import { WRITE_REMOTE_CONFIG_ERROR_NAME } from '../constants.js';
+export class DefaultRemoteConfigManager {
+    config;
+    serviceClient;
+    storageClient;
+    constructor(config, options) {
+        this.config = config;
+        this.serviceClient = options.serviceClient;
+        this.storageClient = options.storageClient;
+    }
+    async loadRemoteConfig() {
+        if (!this.config.remoteConfigId || !this.config.remoteConfigAuthToken) {
+            this.config.logger.debug('no remote config id or auth token provided, skipping remote config load');
+            return;
+        }
+        try {
+            const remoteConfigData = await this.loadRemoteConfigData();
+            if (!!remoteConfigData?.version && remoteConfigData.version > this.config.remoteConfigVersion) {
+                this.config.setRemoteConfigData(remoteConfigData);
+            }
+        }
+        catch (e) {
+            this.config.logger.debug(`caught error loading remote config: ${e}`);
+        }
+    }
+    async loadRemoteConfigData() {
+        const remoteConfigData = await this.storageClient.load();
+        if (!remoteConfigData) {
+            this.config.logger.debug('unable to load remote config from storage');
+            return null;
+        }
+        if (!this.isValidRemoteConfigId(remoteConfigData.id)) {
+            this.config.logger.debug(`remote config ID in static config does not match ID found in storage ${remoteConfigData.id}`);
+            return null;
+        }
+        return remoteConfigData;
+    }
+    isValidRemoteConfigId(remoteConfigId) {
+        return remoteConfigId === this.config.remoteConfigId;
+    }
+    shouldUpdateRemoteConfig(context) {
+        return context.remoteConfigUpdateData.shouldUpdate;
+    }
+    async updateRemoteConfig(context) {
+        const desiredVersion = context.remoteConfigUpdateData.desiredVersion ?? 0;
+        const remoteConfigData = await this.fetchRemoteConfigData(desiredVersion, context);
+        if (!remoteConfigData) {
+            return;
+        }
+        try {
+            await this.storageClient.save(remoteConfigData);
+            context.logger.debug(`successfully updated remote config to version ${remoteConfigData.version}`);
+        }
+        catch (e) {
+            context.logger.debug(`unable to save remote config version ${remoteConfigData.version} to storage: ${e}`, {
+                errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
+            });
+        }
+    }
+    async fetchRemoteConfigData(desiredVersion, context) {
+        try {
+            const { remoteConfigMaxFetchAttempts, remoteConfigRetryIntervalMs } = this.config;
+            for (let i = 0; i < remoteConfigMaxFetchAttempts; i++) {
+                const remoteConfigData = await this.serviceClient.fetch({ version: desiredVersion });
+                if (!!remoteConfigData && remoteConfigData.version >= desiredVersion) {
+                    return remoteConfigData;
+                }
+                else {
+                    await this.sleepBetweenFetchAttempts(remoteConfigRetryIntervalMs);
+                }
+            }
+            context.logger.debug(`unable to fetch remote config version ${desiredVersion} or higher: reached ${remoteConfigMaxFetchAttempts} fetch attempts`, {
+                errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
+            });
+        }
+        catch (e) {
+            context.logger.debug(`unable to fetch remote config version ${desiredVersion} or higher: ${e}`, {
+                errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
+            });
+        }
+        return null;
+    }
+    async sleepBetweenFetchAttempts(ms) {
+        await sleep(ms);
+    }
+}

package/lib/esm/config/remote_config/manager/index.js

@@ -0,0 +1,2 @@
+export * from './IRemoteConfigManager.js';
+export * from './DefaultRemoteConfigManager.js';

package/lib/esm/config/remote_config/model/index.js

@@ -1,2 +1,2 @@
 export * from './RemoteConfigData.js';
-export * from './RemoteConfigUpdateRequestData.js';
+export * from './RemoteConfigNotifyRequestPayload.js';

package/lib/esm/config/remote_config/update_parser/DefaultNotifyRemoteConfigUpdateParser.js

@@ -0,0 +1,60 @@
+import { DefaultTimestampHmacHeaderValidator, PUSH_DATA_FEATURE_HEADER_NAME, PUSH_DATA_HMAC_HEADER_NAME, } from '../../../utils/index.js';
+import { REMOTE_CONFIG_PUSH_DATA_FEATURE_NAME, WRITE_REMOTE_CONFIG_ERROR_NAME } from '../constants.js';
+import { HttpMethod } from '../../../http/index.js';
+export class DefaultNotifyRemoteConfigUpdateParser {
+    config;
+    timestampHmacHeaderValidator;
+    constructor(config, options) {
+        this.config = config;
+        this.timestampHmacHeaderValidator =
+            options.timestampHmacHeaderValidator ??
+                new DefaultTimestampHmacHeaderValidator(config, config.remoteConfigAuthToken, options.base64Utils, options.hmacUtils);
+    }
+    async isUpdateRequest({ requestData: { request } }) {
+        return (request.method === HttpMethod.POST &&
+            request.headers.get(PUSH_DATA_FEATURE_HEADER_NAME) === REMOTE_CONFIG_PUSH_DATA_FEATURE_NAME &&
+            !!request.headers.get(PUSH_DATA_HMAC_HEADER_NAME));
+    }
+    async parseUpdate(context) {
+        if (!(await this.isNotifyRequestValid(context))) {
+            return { shouldUpdate: false };
+        }
+        const updateData = { shouldUpdate: true };
+        const desiredVersion = await this.getDesiredRemoteConfigVersion(context);
+        context.logger.debug(`got notify request for remote config version ${desiredVersion}`);
+        if (desiredVersion) {
+            updateData.desiredVersion = desiredVersion;
+        }
+        return updateData;
+    }
+    async isNotifyRequestValid(context) {
+        const timestampHmacHeader = context.requestData.request.headers.get(PUSH_DATA_HMAC_HEADER_NAME);
+        const isValid = !!timestampHmacHeader &&
+            (await this.timestampHmacHeaderValidator.isValid(timestampHmacHeader, context.logger));
+        if (!isValid) {
+            context.logger.debug(`invalid remote config notify request hmac header received: ${timestampHmacHeader}`, {
+                errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
+            });
+        }
+        return isValid;
+    }
+    async getDesiredRemoteConfigVersion(context) {
+        let notifyRequestPayload;
+        try {
+            notifyRequestPayload = await context.requestData.request.json();
+        }
+        catch (e) {
+            context.logger.debug(`could not parse update request body: ${e}`, {
+                errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
+            });
+            return null;
+        }
+        if (!notifyRequestPayload?.version) {
+            context.logger.debug(`no version on update request body: ${notifyRequestPayload}`, {
+                errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
+            });
+            return null;
+        }
+        return notifyRequestPayload.version;
+    }
+}

package/lib/esm/config/remote_config/update_parser/index.js

@@ -0,0 +1,2 @@
+export * from './DefaultNotifyRemoteConfigUpdateParser.js';
+export * from './IRemoteConfigUpdateParser.js';