perimeterx-js-core 0.7.1 → 0.8.0

package/lib/impl/cipher/SubtleCryptoCipherUtils.js

@@ -0,0 +1,38 @@
+export class SubtleCryptoCipherUtils {
+    base64Utils;
+    subtleCrypto;
+    constructor(base64Utils, subtleCrypto = crypto.subtle) {
+        this.subtleCrypto = subtleCrypto;
+        this.base64Utils = base64Utils;
+    }
+    async pbkdf2Decrypt(secret, encryptedString, iterations, salt, options) {
+        const ivlen = options?.ivlen || 16;
+        const keylen = options?.keylen || 32;
+        const bitsLength = (ivlen + keylen) * 8;
+        const encodedPassword = new TextEncoder().encode(secret);
+        const encodedSalt = this.base64ToArrayBuffer(salt);
+        const importedKey = await this.subtleCrypto.importKey('raw', encodedPassword, 'PBKDF2', false, ['deriveBits']);
+        const params = { name: 'PBKDF2', hash: 'SHA-256', salt: encodedSalt, iterations: iterations };
+        const derivation = await this.subtleCrypto.deriveBits(params, importedKey, bitsLength);
+        const derivedKey = derivation.slice(0, keylen);
+        const iv = derivation.slice(keylen);
+        const cookieBuffer = this.base64ToArrayBuffer(encryptedString);
+        const importedDecryptionKey = await this.subtleCrypto.importKey('raw', derivedKey, { name: 'AES-CBC' }, false, [
+            'decrypt',
+        ]);
+        const decrypted = await this.subtleCrypto.decrypt({
+            name: 'AES-CBC',
+            iv: iv,
+        }, importedDecryptionKey, cookieBuffer);
+        return new TextDecoder('utf-8').decode(decrypted);
+    }
+    base64ToArrayBuffer(base64String) {
+        const binaryString = this.base64Utils.base64Decode(base64String);
+        const length = binaryString.length;
+        const bytes = new Uint8Array(length);
+        binaryString.split('').forEach((char, index) => {
+            bytes[index] = char.charCodeAt(0);
+        });
+        return bytes.buffer;
+    }
+}

package/lib/{utils → impl}/hash/CryptoHashUtils.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import * as crypto from 'crypto';
-import { IHashUtils } from './IHashUtils';
-import { Algorithm } from '../Algorithm';
+import { Algorithm, IHashUtils } from '../../utils';
 declare type CryptoModule = typeof crypto;
 export declare class CryptoHashUtils implements IHashUtils {
     private readonly crypto;

package/lib/impl/hash/CryptoHashUtils.js

@@ -0,0 +1,10 @@
+import * as crypto from 'crypto';
+export class CryptoHashUtils {
+    crypto;
+    constructor(cryptoModule = crypto) {
+        this.crypto = cryptoModule;
+    }
+    async hashString(text, algo) {
+        return this.crypto.createHash(algo).update(text).digest('hex');
+    }
+}

package/lib/{utils → impl}/hash/CryptoJSHashUtils.d.ts

@@ -1,5 +1,4 @@
-import { IHashUtils } from './IHashUtils';
-import { Algorithm } from '../Algorithm';
+import { Algorithm, IHashUtils } from '../../utils';
 export declare class CryptoJSHashUtils implements IHashUtils {
     hashString(text: string, algo: Algorithm): string;
 }

package/lib/{utils → impl}/hash/CryptoJSHashUtils.js

@@ -1,5 +1,5 @@
 import cryptoJs from 'crypto-js';
-import { Algorithm } from '../Algorithm';
+import { Algorithm } from '../../utils';
 export class CryptoJSHashUtils {
     hashString(text, algo) {
         switch (algo) {

package/lib/{utils → impl}/hash/SubtleCryptoHashUtils.d.ts

@@ -1,5 +1,4 @@
-import { Algorithm } from '../Algorithm';
-import { IHashUtils } from './IHashUtils';
+import { Algorithm, IHashUtils } from '../../utils';
 export declare class SubtleCryptoHashUtils implements IHashUtils {
     private readonly subtle;
     constructor(subtleCrypto?: SubtleCrypto);

package/lib/impl/hash/SubtleCryptoHashUtils.js

@@ -0,0 +1,21 @@
+import * as crypto from 'crypto';
+import { Algorithm } from '../../utils';
+export class SubtleCryptoHashUtils {
+    subtle;
+    constructor(subtleCrypto = crypto.subtle) {
+        this.subtle = subtleCrypto;
+    }
+    async hashString(text, algo) {
+        const textUint8 = new TextEncoder().encode(text);
+        const hashBuffer = await this.subtle.digest(this.convertAlgo(algo), textUint8);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+    }
+    convertAlgo(algo) {
+        switch (algo) {
+            case Algorithm.SHA256:
+            default:
+                return 'SHA-256';
+        }
+    }
+}

package/lib/{utils → impl}/hmac/CryptoHmacUtils.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import * as crypto from 'crypto';
-import { IHmacUtils } from './IHmacUtils';
-import { Algorithm } from '../Algorithm';
+import { Algorithm, IHmacUtils } from '../../utils';
 declare type CryptoModule = typeof crypto;
 export declare class CryptoHmacUtils implements IHmacUtils {
     private readonly crypto;

package/lib/{utils → impl}/hmac/CryptoHmacUtils.js

@@ -1,6 +1,7 @@
 import * as crypto from 'crypto';
-import { Algorithm } from '../Algorithm';
+import { Algorithm } from '../../utils';
 export class CryptoHmacUtils {
+    crypto;
     constructor(cryptoModule = crypto) {
         this.crypto = cryptoModule;
     }

package/lib/{utils → impl}/hmac/CryptoJSHmacUtils.d.ts

@@ -1,5 +1,4 @@
-import { IHmacUtils } from './IHmacUtils';
-import { Algorithm } from '../Algorithm';
+import { Algorithm, IHmacUtils } from '../../utils';
 export declare class CryptoJSHmacUtils implements IHmacUtils {
     createHmac(algo: Algorithm, payload: string, secret: string): string;
 }

package/lib/{utils → impl}/hmac/CryptoJSHmacUtils.js

@@ -1,5 +1,5 @@
 import cryptoJs from 'crypto-js';
-import { Algorithm } from '../Algorithm';
+import { Algorithm } from '../../utils';
 export class CryptoJSHmacUtils {
     createHmac(algo, payload, secret) {
         switch (algo) {

package/lib/{http/impl → impl/http}/phin/PhinHttpClient.d.ts

@@ -1,4 +1,4 @@
-import { HttpSendOptions, IHttpClient, IIncomingResponse, IOutgoingRequest } from '../../interfaces';
+import { HttpSendOptions, IHttpClient, IIncomingResponse, IOutgoingRequest } from '../../../http/interfaces';
 export declare class PhinHttpClient implements IHttpClient {
     private readonly httpsKeepAliveAgent;
     constructor();

package/lib/impl/http/phin/PhinHttpClient.js

@@ -0,0 +1,31 @@
+import { Agent as HttpAgent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+import phin from 'phin';
+import { EnforcerTimeoutError } from '../../../utils';
+import { joinHeaderValues, } from '../../../http/interfaces';
+import { PhinIncomingResponse } from './PhinIncomingResponse';
+export class PhinHttpClient {
+    httpsKeepAliveAgent;
+    constructor() {
+        this.httpsKeepAliveAgent = new HttpsAgent({ keepAlive: true });
+    }
+    async send(request, options) {
+        try {
+            const res = await phin.promisified({
+                url: request.url,
+                method: request.method,
+                headers: joinHeaderValues(request.headers),
+                data: request.body,
+                timeout: options?.timeoutMs || null,
+                core: {
+                    agent: request.url.startsWith('https://') ? this.httpsKeepAliveAgent : new HttpAgent(),
+                },
+            });
+            return new PhinIncomingResponse(res);
+        }
+        catch (e) {
+            const isTimeout = e.toString().toLowerCase().includes('timeout');
+            throw isTimeout ? new EnforcerTimeoutError(options.timeoutMs) : e;
+        }
+    }
+}

package/lib/{http/impl → impl/http}/phin/PhinIncomingResponse.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="node" />
 import { IResponse } from 'phin';
-import { IFormData, IIncomingResponse, ReadonlyHeaders } from '../../interfaces';
+import { IFormData, IIncomingResponse, IURLSearchParams, ReadonlyHeaders } from '../../../http';
 export declare class PhinIncomingResponse implements IIncomingResponse {
     readonly status: number;
     readonly headers: ReadonlyHeaders;
     readonly body: Buffer;
     constructor(response: IResponse);
     formData(): Promise<IFormData>;
-    formUrlEncoded(): Promise<URLSearchParams>;
+    formUrlEncoded(): Promise<IURLSearchParams>;
     json(): Promise<any>;
     text(): Promise<string>;
 }

package/lib/impl/http/phin/PhinIncomingResponse.js

@@ -0,0 +1,23 @@
+import { CONTENT_TYPE_HEADER_NAME, MultipartFormDataUtils, URLUtils, } from '../../../http';
+export class PhinIncomingResponse {
+    status;
+    headers;
+    body;
+    constructor(response) {
+        this.status = response.statusCode;
+        this.body = response.body;
+        this.headers = Object.fromEntries(Object.entries(response.headers).map(([key, val]) => [key, typeof val === 'string' ? [val] : val]));
+    }
+    async formData() {
+        return MultipartFormDataUtils.createFormDataWithoutFiles(await this.text(), this.headers[CONTENT_TYPE_HEADER_NAME]?.[0]);
+    }
+    async formUrlEncoded() {
+        return URLUtils.parseSearchParams(await this.text());
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+    async text() {
+        return this.body.toString();
+    }
+}

package/lib/{utils → impl}/ip_range_checker/DefaultIpRangeChecker.d.ts

@@ -1,4 +1,4 @@
-import { IIpRangeChecker } from './IIpRangeChecker';
+import { IIpRangeChecker } from '../../utils';
 export declare class DefaultIpRangeChecker implements IIpRangeChecker {
     isIpInRange(ip: string, range: string | string[]): boolean;
 }

package/lib/{utils → impl}/request_id_generator/UuidRequestIdGenerator.d.ts

@@ -1,4 +1,4 @@
-import { IRequestIdGenerator } from './IRequestIdGenerator';
+import { IRequestIdGenerator } from '../../utils';
 export declare class UuidRequestIdGenerator implements IRequestIdGenerator {
     generateRequestId(): string;
 }

package/lib/{utils → impl}/url_parser/DefaultUrlParser.d.ts

@@ -1,13 +1,13 @@
-import { IURLParser } from './IURLParser';
 import { IURL } from '../../http';
+import { IURLParser } from '../../utils';
 export type UrlParserOptions = {
     normalize?: boolean;
     reverseCharactersEncoding?: boolean;
 };
 export declare class DefaultUrlParser implements IURLParser {
-    private options;
+    protected options: UrlParserOptions;
     constructor(options?: UrlParserOptions);
     parse(rawUrl: string): IURL;
-    private reverseCharactersEncoding;
-    private normalize;
+    protected reverseCharactersEncoding(path: string): string;
+    protected normalize(path: string): string;
 }

package/lib/{utils → impl}/url_parser/DefaultUrlParser.js

@@ -1,9 +1,15 @@
+import { URLUtils } from '../../http';
 export class DefaultUrlParser {
+    options;
     constructor(options) {
-        this.options = Object.assign({ normalize: true, reverseCharactersEncoding: false }, options);
+        this.options = {
+            normalize: true,
+            reverseCharactersEncoding: false,
+            ...options,
+        };
     }
     parse(rawUrl) {
-        const url = new URL(rawUrl);
+        const url = URLUtils.parseURL(rawUrl);
         if (this.options.reverseCharactersEncoding) {
             url.pathname = this.reverseCharactersEncoding(url.pathname);
         }
@@ -13,6 +19,7 @@ export class DefaultUrlParser {
         return url;
     }
     reverseCharactersEncoding(path) {
+        // NOTICE: Find a suitable polyfill in case decodeURI doesn't exist in the global scope
         return decodeURI(path);
     }
     normalize(path) {

package/lib/logger/HttpLogServiceClient.js

@@ -1,16 +1,12 @@
-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 { EXTERNAL_LOGGER_SERVICE_PATH } from './constants';
-import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../http';
+import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, URLUtils, } from '../http';
 import { getAuthorizationHeader } from '../utils';
 export class HttpLogServiceClient {
+    appId;
+    backendUrl;
+    loggerAuthToken;
+    logger;
+    httpClient;
     constructor(config, httpClient) {
         this.appId = config.appId;
         this.backendUrl = config.backendScoreApiUrl;
@@ -18,20 +14,18 @@ export class HttpLogServiceClient {
         this.logger = config.logger;
         this.httpClient = httpClient;
     }
-    sendLogs(context, logs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const enrichedLogs = logs.map((log) => this.enrichLogRecord(context, log));
-                yield this.postLogs(enrichedLogs);
-            }
-            catch (e) {
-                this.logger.error(`unable to send logs: ${e}`);
-            }
-        });
+    async sendLogs(context, logs) {
+        try {
+            const enrichedLogs = logs.map((log) => this.enrichLogRecord(context, log));
+            await this.postLogs(enrichedLogs);
+        }
+        catch (e) {
+            this.logger.error(`unable to send logs: ${e}`);
+        }
     }
     enrichLogRecord(context, log) {
         const requestData = context.requestData;
-        const url = new URL(requestData.rawUrl);
+        const url = URLUtils.parseURL(requestData.rawUrl);
         const logMeta = {
             container: 'enforcer',
             appID: this.appId,
@@ -41,20 +35,18 @@ export class HttpLogServiceClient {
             path: url.pathname + requestData.url.search,
             requestId: context.requestId,
         };
-        return Object.assign(Object.assign({}, logMeta), log);
+        return { ...logMeta, ...log };
     }
-    postLogs(logRecords) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const url = `${this.backendUrl}${EXTERNAL_LOGGER_SERVICE_PATH}`;
-            const method = HttpMethod.POST;
-            const headers = {
-                [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
-                [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.loggerAuthToken)],
-            };
-            const body = JSON.stringify(logRecords);
-            const req = new OutgoingRequestImpl({ url, method, headers, body });
-            const res = yield this.httpClient.send(req);
-            return (res === null || res === void 0 ? void 0 : res.status) === 200;
-        });
+    async postLogs(logRecords) {
+        const url = `${this.backendUrl}${EXTERNAL_LOGGER_SERVICE_PATH}`;
+        const method = HttpMethod.POST;
+        const headers = {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+            [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.loggerAuthToken)],
+        };
+        const body = JSON.stringify(logRecords);
+        const req = new OutgoingRequestImpl({ url, method, headers, body });
+        const res = await this.httpClient.send(req);
+        return res?.status === 200;
     }
 }

package/lib/logger/LoggerBase.js

@@ -1,5 +1,7 @@
 import { LoggerSeverity } from './LoggerSeverity';
 export class LoggerBase {
+    loggerSeverity;
+    logs;
     constructor(loggerSeverity = LoggerSeverity.ERROR, logs = []) {
         this.loggerSeverity = loggerSeverity;
         this.logs = logs;

package/lib/phase/impl/AdditionalActivityHandlerPhase.js

@@ -1,22 +1,11 @@
-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 { AdditionalActivityHandlerUtils } from '../../additional_activity_handler';
 export class AdditionalActivityHandlerPhase {
+    config;
     constructor(config) {
         this.config = config;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.config.logger.debug('calling additional activity handler');
-            yield AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler(this.config, context);
-            return { done: false };
-        });
+    async execute(context) {
+        await AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler(this.config, context);
+        return { done: false };
     }
 }

package/lib/phase/impl/CompositePhase.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 CompositePhase {
+    phases;
     constructor(phases) {
         this.phases = phases;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let result;
-            for (const phase of this.phases) {
-                result = yield phase.execute(context);
-                if (result.done) {
-                    break;
-                }
+    async execute(context) {
+        let result;
+        for (const phase of this.phases) {
+            result = await phase.execute(context);
+            if (result.done) {
+                break;
             }
-            return result;
-        });
+        }
+        return result;
     }
 }

package/lib/phase/impl/CreateBlockResponsePhase.js

@@ -1,42 +1,34 @@
-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 { MinimalResponseUtils } from '../../http';
 import { PXHDSource, PXHDUtils } from '../../pxhd';
 import { Action } from '../../action';
 import { PRODUCT_PRIORITY_ORDER } from '../../products';
 export class CreateBlockResponsePhase {
+    config;
+    blockers;
+    cors;
     constructor(config, blockers, cors) {
         this.config = config;
         this.blockers = blockers;
         this.cors = cors;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (context.action !== Action.BLOCK) {
-                return { done: false };
-            }
-            this.config.logger.debug('create block response phase');
-            let response = this.createBlockResponse(context);
-            if (!response) {
-                return { done: false };
-            }
-            response = yield this.addHeadersToResponse(response, context);
-            return { done: true, response };
-        });
+    async execute(context) {
+        if (context.action !== Action.BLOCK) {
+            return { done: false };
+        }
+        this.config.logger.debug('create block response phase');
+        let response = this.createBlockResponse(context);
+        if (!response) {
+            return { done: false };
+        }
+        response = await this.addHeadersToResponse(response, context);
+        return { done: true, response };
     }
     createBlockResponse(context) {
         let response = null;
         for (const name of PRODUCT_PRIORITY_ORDER) {
             if (context.reasons[name]) {
                 const blocker = this.blockers[name];
-                if (blocker === null || blocker === void 0 ? void 0 : blocker.shouldBlock(context)) {
+                if (blocker?.shouldBlock(context)) {
                     this.config.logger.debug(`returning ${name} block response`);
                     response = blocker.createBlockResponse(context);
                     break;
@@ -45,17 +37,14 @@ export class CreateBlockResponsePhase {
         }
         return response;
     }
-    addHeadersToResponse(response, context) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!context.isMobile && ((_a = context.pxhd) === null || _a === void 0 ? void 0 : _a.source) === PXHDSource.RISK) {
-                response = PXHDUtils.addPxhdToMinimalResponse(context, response);
-            }
-            if (this.config.corsSupportEnabled && ((_b = this.cors) === null || _b === void 0 ? void 0 : _b.isCorsRequest(context))) {
-                const corsHeaders = yield this.cors.getCorsBlockHeaders(context);
-                response = MinimalResponseUtils.appendHeaders(response, corsHeaders);
-            }
-            return response;
-        });
+    async addHeadersToResponse(response, context) {
+        if (!context.isMobile && context.pxhd?.source === PXHDSource.RISK) {
+            response = PXHDUtils.addPxhdToMinimalResponse(context, response);
+        }
+        if (this.config.corsSupportEnabled && this.cors?.isCorsRequest(context)) {
+            const corsHeaders = await this.cors.getCorsBlockHeaders(context);
+            response = MinimalResponseUtils.appendHeaders(response, corsHeaders);
+        }
+        return response;
     }
 }

package/lib/phase/impl/DecideActionPhase.js

@@ -1,29 +1,19 @@
-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 { LoggerSeverity } from '../../logger';
 import { getDecisionFromContext } from '../../action';
 export class DecideActionPhase {
+    config;
     constructor(config) {
         this.config = config;
     }
-    updateContextDecision(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { action, reasons } = getDecisionFromContext(context);
-            if (this.config.logger.getLoggerSeverity() === LoggerSeverity.DEBUG) {
-                const productReasons = Object.entries(reasons)
-                    .map(([prod, reason]) => `${prod} -> ${reason}`)
-                    .join(', ');
-                this.config.logger.debug(`decision: ${action}, reasons: ${productReasons}`);
-            }
-            context.action = action;
-            context.reasons = reasons;
-        });
+    async updateContextDecision(context) {
+        const { action, reasons } = getDecisionFromContext(context);
+        if (this.config.logger.getLoggerSeverity() === LoggerSeverity.DEBUG) {
+            const productReasons = Object.entries(reasons)
+                .map(([prod, reason]) => `${prod} -> ${reason}`)
+                .join(', ');
+            this.config.logger.debug(`decision: ${action}, reasons: ${productReasons}`);
+        }
+        context.action = action;
+        context.reasons = reasons;
     }
 }