perimeterx-js-core 0.7.0 → 0.8.0

package/lib/products/credential_intelligence/endpoint/extractor/CustomCredentialExtractor.js

@@ -1,24 +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 class CustomCredentialExtractor {
+    callback;
     constructor(callback) {
         this.callback = callback;
     }
-    extractCredentials(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.callback(request.getUnderlyingRequest());
-            }
-            catch (e) {
-                return null;
-            }
-        });
+    async extractCredentials(request) {
+        try {
+            return await this.callback(request.getUnderlyingRequest());
+        }
+        catch (e) {
+            return null;
+        }
     }
 }

package/lib/products/credential_intelligence/endpoint/extractor/HeaderCredentialExtractor.js

@@ -1,4 +1,6 @@
 export class HeaderCredentialExtractor {
+    userField;
+    passField;
     constructor(userField, passField) {
         this.userField = userField;
         this.passField = passField;

package/lib/products/credential_intelligence/endpoint/extractor/QueryParamCredentialExtractor.d.ts

@@ -1,6 +1,6 @@
+import { DeepReadonly } from 'ts-essentials';
 import { ICredentialExtractor } from './ICredentialExtractor';
 import { Credentials } from '../../model';
-import { DeepReadonly } from 'ts-essentials';
 import { IIncomingRequest } from '../../../../http';
 export declare class QueryParamCredentialExtractor<Req> implements ICredentialExtractor<Req> {
     protected readonly userField: string;

package/lib/products/credential_intelligence/endpoint/extractor/QueryParamCredentialExtractor.js

@@ -1,23 +1,18 @@
-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 { URLUtils } from '../../../../http';
 export class QueryParamCredentialExtractor {
+    userField;
+    passField;
     constructor(userField, passField) {
         this.userField = userField;
         this.passField = passField;
     }
-    extractCredentials(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { searchParams } = new URL(request.url);
-            const user = searchParams.get(this.userField);
-            const pass = searchParams.get(this.passField);
-            return typeof user === 'string' || typeof pass === 'string' ? { user, pass } : null;
-        });
+    async extractCredentials(request) {
+        const { searchParams } = URLUtils.parseURL(request.url);
+        if (!searchParams) {
+            return null;
+        }
+        const user = searchParams.get(this.userField);
+        const pass = searchParams.get(this.passField);
+        return typeof user === 'string' || typeof pass === 'string' ? { user, pass } : null;
     }
 }

package/lib/products/credential_intelligence/endpoint/hash_protocol/MultistepHashProtocol.js

@@ -1,30 +1,20 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { Algorithm } from '../../../../utils';
 import { SsoStep } from './SsoStep';
 import { CredentialIntelligenceVersion } from './CredentialIntelligenceVersion';
 export class MultistepHashProtocol {
+    hashUtils;
     constructor(hashUtils) {
         this.hashUtils = hashUtils;
     }
-    hashCredentials({ user, pass }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rawUsername = user !== null && user !== void 0 ? user : null;
-            const hashedPassword = typeof pass === 'string' ? yield this.hashUtils.hashString(pass, Algorithm.SHA256) : null;
-            return {
-                rawUsername,
-                hashedUsername: rawUsername,
-                hashedPassword,
-                ciVersion: CredentialIntelligenceVersion.MULTI_STEP,
-                ssoStep: user ? SsoStep.USER : SsoStep.PASS,
-            };
-        });
+    async hashCredentials({ user, pass }) {
+        const rawUsername = user ?? null;
+        const hashedPassword = typeof pass === 'string' ? await this.hashUtils.hashString(pass, Algorithm.SHA256) : null;
+        return {
+            rawUsername,
+            hashedUsername: rawUsername,
+            hashedPassword,
+            ciVersion: CredentialIntelligenceVersion.MULTI_STEP,
+            ssoStep: user ? SsoStep.USER : SsoStep.PASS,
+        };
     }
 }

package/lib/products/credential_intelligence/endpoint/hash_protocol/SingleStepAndMultistepHashProtocol.js

@@ -1,25 +1,16 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export class SingleStepAndMultistepHashProtocol {
+    singleStepHashProtocol;
+    multistepHashProtocol;
     constructor(singleStepHashProtocol, multistepHashProtocol) {
         this.singleStepHashProtocol = singleStepHashProtocol;
         this.multistepHashProtocol = multistepHashProtocol;
     }
-    hashCredentials(credentials) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (credentials.user && credentials.pass) {
-                return this.singleStepHashProtocol.hashCredentials(credentials);
-            }
-            else {
-                return this.multistepHashProtocol.hashCredentials(credentials);
-            }
-        });
+    async hashCredentials(credentials) {
+        if (credentials.user && credentials.pass) {
+            return this.singleStepHashProtocol.hashCredentials(credentials);
+        }
+        else {
+            return this.multistepHashProtocol.hashCredentials(credentials);
+        }
     }
 }

package/lib/products/credential_intelligence/endpoint/hash_protocol/SingleStepHashProtocol.js

@@ -1,30 +1,20 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { Algorithm, isEmailAddress } from '../../../../utils';
 import { CredentialIntelligenceVersion } from './CredentialIntelligenceVersion';
 export class SingleStepHashProtocol {
+    hashUtils;
     constructor(hashUtils) {
         this.hashUtils = hashUtils;
     }
-    hashCredentials({ user, pass }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const normalizedUsername = isEmailAddress(user) ? this.normalizeEmailAddress(user) : user;
-            const hashedUsername = yield this.sha256(normalizedUsername);
-            const hashedPassword = yield this.sha256(hashedUsername + (yield this.sha256(pass)));
-            return {
-                ciVersion: CredentialIntelligenceVersion.SINGLE_STEP,
-                rawUsername: user,
-                hashedUsername,
-                hashedPassword,
-            };
-        });
+    async hashCredentials({ user, pass }) {
+        const normalizedUsername = isEmailAddress(user) ? this.normalizeEmailAddress(user) : user;
+        const hashedUsername = await this.sha256(normalizedUsername);
+        const hashedPassword = await this.sha256(hashedUsername + (await this.sha256(pass)));
+        return {
+            ciVersion: CredentialIntelligenceVersion.SINGLE_STEP,
+            rawUsername: user,
+            hashedUsername,
+            hashedPassword,
+        };
     }
     normalizeEmailAddress(emailAddress) {
         const lowercaseEmail = emailAddress.trim().toLowerCase();
@@ -41,9 +31,7 @@ export class SingleStepHashProtocol {
         }
         return `${normalizedUsername}${domain}`;
     }
-    sha256(text) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.hashUtils.hashString(text, Algorithm.SHA256);
-        });
+    async sha256(text) {
+        return await this.hashUtils.hashString(text, Algorithm.SHA256);
     }
 }

package/lib/products/credential_intelligence/endpoint/login_successful/BodyLoginSuccessfulParser.js

@@ -1,20 +1,10 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export class BodyLoginSuccessfulParser {
+    bodyRegex;
     constructor(regex) {
         this.bodyRegex = new RegExp(regex);
     }
-    isLoginSuccessful(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: Possibly add IBody methods to IOutgoingResponse interface?
-            return this.bodyRegex.test(response.body);
-        });
+    async isLoginSuccessful(response) {
+        // TODO: Possibly add IBody methods to IOutgoingResponse interface?
+        return this.bodyRegex.test(response.body);
     }
 }

package/lib/products/credential_intelligence/endpoint/login_successful/CustomLoginSuccessfulParser.js

@@ -1,26 +1,16 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export class CustomLoginSuccessfulParser {
+    callback;
     constructor(callback) {
         this.callback = callback;
     }
-    isLoginSuccessful(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const retVal = yield this.callback(response.getUnderlyingResponse());
-                return typeof retVal === 'boolean' ? retVal : null;
-            }
-            catch (_a) {
-                // We cannot say definitively if the login was successful or not here
-                return null;
-            }
-        });
+    async isLoginSuccessful(response) {
+        try {
+            const retVal = await this.callback(response.getUnderlyingResponse());
+            return typeof retVal === 'boolean' ? retVal : null;
+        }
+        catch {
+            // We cannot say definitively if the login was successful or not here
+            return null;
+        }
     }
 }

package/lib/products/credential_intelligence/endpoint/login_successful/HeaderLoginSuccessfulParser.js

@@ -1,23 +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 class HeaderLoginSuccessfulParser {
+    headerName;
+    headerValue;
     constructor(headerName, headerValue) {
         this.headerName = headerName;
         this.headerValue = headerValue || null;
     }
-    isLoginSuccessful(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.headerValue) {
-                return response.headers.get(this.headerName) === this.headerValue;
-            }
-            return response.headers.has(this.headerName);
-        });
+    async isLoginSuccessful(response) {
+        if (this.headerValue) {
+            return response.headers.get(this.headerName) === this.headerValue;
+        }
+        return response.headers.has(this.headerName);
     }
 }

package/lib/products/credential_intelligence/endpoint/login_successful/LoginSuccessfulParserFactory.js

@@ -6,19 +6,20 @@ import { StatusLoginSuccessfulParser } from './StatusLoginSuccessfulParser';
 import { EnforcerError } from '../../../../utils';
 export class LoginSuccessfulParserFactory {
     static create(config, endpointConfig) {
-        var _a;
         const { ciDefaultLoginSuccessfulReportingMethod, ciDefaultLoginSuccessfulBodyRegex, ciDefaultLoginSuccessfulStatus, ciDefaultLoginSuccessfulCustomCallback, ciDefaultLoginSuccessfulHeaderName, ciDefaultLoginSuccessfulHeaderValue, } = config;
         const { login_successful_reporting_method, login_successful_callback, login_successful_statuses, login_successful_body_regex, login_successful_header_name, login_successful_header_value, } = endpointConfig;
-        const reportingMethod = (_a = login_successful_reporting_method !== null && login_successful_reporting_method !== void 0 ? login_successful_reporting_method : ciDefaultLoginSuccessfulReportingMethod) !== null && _a !== void 0 ? _a : LoginSuccessfulReportingMethod.STATUS;
+        const reportingMethod = login_successful_reporting_method ??
+            ciDefaultLoginSuccessfulReportingMethod ??
+            LoginSuccessfulReportingMethod.STATUS;
         switch (reportingMethod) {
             case LoginSuccessfulReportingMethod.BODY:
-                return new BodyLoginSuccessfulParser(login_successful_body_regex !== null && login_successful_body_regex !== void 0 ? login_successful_body_regex : ciDefaultLoginSuccessfulBodyRegex);
+                return new BodyLoginSuccessfulParser(login_successful_body_regex ?? ciDefaultLoginSuccessfulBodyRegex);
             case LoginSuccessfulReportingMethod.CUSTOM:
-                return new CustomLoginSuccessfulParser(login_successful_callback !== null && login_successful_callback !== void 0 ? login_successful_callback : ciDefaultLoginSuccessfulCustomCallback);
+                return new CustomLoginSuccessfulParser(login_successful_callback ?? ciDefaultLoginSuccessfulCustomCallback);
             case LoginSuccessfulReportingMethod.HEADER:
-                return new HeaderLoginSuccessfulParser(login_successful_header_name !== null && login_successful_header_name !== void 0 ? login_successful_header_name : ciDefaultLoginSuccessfulHeaderName, login_successful_header_value !== null && login_successful_header_value !== void 0 ? login_successful_header_value : ciDefaultLoginSuccessfulHeaderValue);
+                return new HeaderLoginSuccessfulParser(login_successful_header_name ?? ciDefaultLoginSuccessfulHeaderName, login_successful_header_value ?? ciDefaultLoginSuccessfulHeaderValue);
             case LoginSuccessfulReportingMethod.STATUS:
-                return new StatusLoginSuccessfulParser(login_successful_statuses !== null && login_successful_statuses !== void 0 ? login_successful_statuses : ciDefaultLoginSuccessfulStatus);
+                return new StatusLoginSuccessfulParser(login_successful_statuses ?? ciDefaultLoginSuccessfulStatus);
             default:
                 throw new EnforcerError('unknown login successful reporting method defined');
         }

package/lib/products/credential_intelligence/endpoint/login_successful/StatusLoginSuccessfulParser.js

@@ -1,19 +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 class StatusLoginSuccessfulParser {
+    statuses;
     constructor(statuses) {
         this.statuses = statuses;
     }
-    isLoginSuccessful(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.statuses.includes(response.status);
-        });
+    async isLoginSuccessful(response) {
+        return this.statuses.includes(response.status);
     }
 }

package/lib/products/credential_intelligence/endpoint/matcher/ExactPathEndpointMatcher.js

@@ -1,4 +1,6 @@
 export class ExactPathEndpointMatcher {
+    pathname;
+    method;
     constructor(pathname, method) {
         this.pathname = pathname;
         this.method = method;

package/lib/products/credential_intelligence/endpoint/matcher/RegexPathEndpointMatcher.js

@@ -1,4 +1,6 @@
 export class RegexPathEndpointMatcher {
+    pathnameRegex;
+    method;
     constructor(pathname, method) {
         this.pathnameRegex = pathname;
         this.method = method;

package/lib/pxde/DefaultDataEnrichment.js

@@ -1,74 +1,60 @@
-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 { Algorithm, PXDE_COOKIE_NAME } from '../utils';
 import { PXDE_COOKIE_DELIMITER, PXDE_COOKIE_PARTS_COUNT, PXDE_HMAC_INDEX, PXDE_PAYLOAD_INDEX } from './constants';
 export class DefaultDataEnrichment {
+    config;
+    base64Utils;
+    hmacUtils;
     constructor(config, base64Utils, hmacUtils) {
         this.config = config;
         this.base64Utils = base64Utils;
         this.hmacUtils = hmacUtils;
     }
-    handlePxde(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const pxdeCookie = context.requestData.cookies[PXDE_COOKIE_NAME];
-                if (pxdeCookie) {
-                    return yield this.parsePxde(pxdeCookie);
-                }
-            }
-            catch (e) {
-                this.config.logger.debug(`unable to parse pxde cookie - ${e}`);
-            }
-            return null;
-        });
+    async handlePxde(context) {
+        try {
+            const pxdeCookie = context.requestData.cookies[PXDE_COOKIE_NAME];
+            if (pxdeCookie) {
+                return await this.parsePxde(pxdeCookie);
+            }
+        }
+        catch (e) {
+            this.config.logger.debug(`unable to parse pxde cookie - ${e}`);
+        }
+        return null;
     }
-    parsePxde(pxdeCookie) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pxdeParts = pxdeCookie.split(PXDE_COOKIE_DELIMITER);
-            if (pxdeParts.length !== PXDE_COOKIE_PARTS_COUNT) {
-                this.config.logger.debug(`malformed pxde cookie: ${pxdeCookie}`);
-                return null;
-            }
-            const hmac = pxdeParts[PXDE_HMAC_INDEX];
-            const encodedPayload = pxdeParts[PXDE_PAYLOAD_INDEX];
-            if (!hmac || !encodedPayload) {
-                this.config.logger.debug(`malformed pxde cookie: hmac: ${hmac}, payload: ${encodedPayload}`);
-                return null;
-            }
-            return {
-                pxde: yield this.parsePxdePayload(encodedPayload),
-                pxdeVerified: yield this.verifyPxdeHmac(hmac, encodedPayload),
-            };
-        });
+    async parsePxde(pxdeCookie) {
+        const pxdeParts = pxdeCookie.split(PXDE_COOKIE_DELIMITER);
+        if (pxdeParts.length !== PXDE_COOKIE_PARTS_COUNT) {
+            this.config.logger.debug(`malformed pxde cookie: ${pxdeCookie}`);
+            return null;
+        }
+        const hmac = pxdeParts[PXDE_HMAC_INDEX];
+        const encodedPayload = pxdeParts[PXDE_PAYLOAD_INDEX];
+        if (!hmac || !encodedPayload) {
+            this.config.logger.debug(`malformed pxde cookie: hmac: ${hmac}, payload: ${encodedPayload}`);
+            return null;
+        }
+        return {
+            pxde: await this.parsePxdePayload(encodedPayload),
+            pxdeVerified: await this.verifyPxdeHmac(hmac, encodedPayload),
+        };
     }
-    verifyPxdeHmac(givenHmac, encodedPayload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return givenHmac === this.hmacUtils.createHmac(Algorithm.SHA256, encodedPayload, this.config.cookieSecret);
-            }
-            catch (e) {
-                this.config.logger.debug(`failed verifying pxde hmac: ${e}`);
-                return false;
-            }
-        });
+    async verifyPxdeHmac(givenHmac, encodedPayload) {
+        try {
+            return givenHmac === this.hmacUtils.createHmac(Algorithm.SHA256, encodedPayload, this.config.cookieSecret);
+        }
+        catch (e) {
+            this.config.logger.debug(`failed verifying pxde hmac: ${e}`);
+            return false;
+        }
     }
-    parsePxdePayload(encodedPayload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const decodedPayload = this.base64Utils.base64Decode(encodedPayload);
-                return JSON.parse(decodedPayload);
-            }
-            catch (e) {
-                this.config.logger.debug(`failed parsing pxde payload: ${e}`);
-                return null;
-            }
-        });
+    async parsePxdePayload(encodedPayload) {
+        try {
+            const decodedPayload = this.base64Utils.base64Decode(encodedPayload);
+            return JSON.parse(decodedPayload);
+        }
+        catch (e) {
+            this.config.logger.debug(`failed parsing pxde payload: ${e}`);
+            return null;
+        }
     }
 }

package/lib/pxhd/PXHDUtils.js

@@ -5,14 +5,14 @@ export var PXHDUtils;
     PXHDUtils.PXHD_SAMESITE_VALUE = 'Lax';
     PXHDUtils.PXHD_PATH_VALUE = '/';
     PXHDUtils.addPxhdToOutgoingResponse = (context, response) => {
-        if (!(context === null || context === void 0 ? void 0 : context.pxhd)) {
+        if (!context?.pxhd) {
             return;
         }
         const setPxhdCookie = PXHDUtils.getPxhdCookieValue(context.pxhd);
         response.headers.append(SET_COOKIE_HEADER_NAME, setPxhdCookie);
     };
     PXHDUtils.addPxhdToMinimalResponse = (context, response) => {
-        if (context === null || context === void 0 ? void 0 : context.pxhd) {
+        if (context?.pxhd) {
             const setPxhdCookie = PXHDUtils.getPxhdCookieValue(context.pxhd);
             return MinimalResponseUtils.appendHeader(response, SET_COOKIE_HEADER_NAME, setPxhdCookie);
         }

package/lib/risk_api/client/PostRiskApiClientBase.d.ts

@@ -1,6 +1,7 @@
 import { ReadonlyContext, RiskApiData } from '../../context';
 import { IConfiguration } from '../../config';
-import { IHttpClient, IIncomingResponse } from '../../http';
+import { IHttpClient, IIncomingResponse, ReadonlyHeaders } from '../../http';
+import { HeaderEntry } from '../../activities';
 import { RiskActivity } from '../model';
 import { IRiskResponse } from '../risk_response';
 import { IRiskApiClient } from './IRiskApiClient';
@@ -29,16 +30,10 @@ export declare abstract class PostRiskApiClientBase<Req, Res> implements IRiskAp
      * @protected
      */
     protected finalizeRiskActivity(riskActivity: RiskActivity): RiskActivity;
-    private addOptionalRiskFields;
-    private addOptionalRiskFieldsToRoot;
-    private addOptionalRiskFieldsToAdditional;
-    private addProductDataToAdditional;
-    private addCustomParamsToAdditional;
-    private addTokenDataToAdditional;
-    private formatRiskHeadersField;
+    protected formatRiskHeadersField(headers: ReadonlyHeaders): HeaderEntry[];
     protected sendRiskActivity(riskActivity: RiskActivity, riskApiData: RiskApiData): Promise<IIncomingResponse>;
-    private getRiskUrl;
-    private getRiskHeaders;
-    private handleS2STimeout;
-    private handleS2SError;
+    protected getRiskUrl(): string;
+    protected getRiskHeaders(): ReadonlyHeaders;
+    protected handleS2STimeout(riskApiData: RiskApiData): RiskApiData;
+    protected handleS2SError(riskApiData: RiskApiData, response: IIncomingResponse, error?: Error): Promise<RiskApiData>;
 }