perimeterx-js-core 0.7.0 → 0.8.0

package/lib/http/utils/UrlSearchParamsImpl.js

@@ -0,0 +1,116 @@
+// This file is based on the implementation found here:
+// https://github.com/pinglu85/BFEdevSolutions/blob/main/Coding-Problems/80.implement-your-own-URLSearchParams.md
+import { URLUtils } from './URLUtils';
+export class UrlSearchParamsImpl {
+    _searchParamsArray;
+    _searchParamsMap;
+    constructor(init) {
+        this._searchParamsArray = [];
+        this._searchParamsMap = new Map();
+        if (init) {
+            if (typeof init !== 'object') {
+                this._constructSearchParamsFromString(init);
+            }
+            else if (Array.isArray(init)) {
+                this._constructSearchParamsFromArray(init);
+            }
+            else {
+                this._constructSearchParamsFromObject(init);
+            }
+        }
+    }
+    append(name, value) {
+        name = String(name);
+        value = String(value);
+        this._saveParam(name, value);
+    }
+    delete(name) {
+        name = String(name);
+        this._searchParamsMap.delete(name);
+        this._searchParamsArray = this._searchParamsArray.filter((param) => param[0] !== name);
+    }
+    forEach(callback) {
+        this._searchParamsArray.forEach((param) => {
+            callback(param[1], param[0], this);
+        });
+    }
+    get(name) {
+        name = String(name);
+        const value = this._searchParamsMap.get(name);
+        return value ? value[0] : null;
+    }
+    getAll(name) {
+        name = String(name);
+        const value = this._searchParamsMap.get(name);
+        return value ? value : [];
+    }
+    has(name) {
+        name = String(name);
+        return this._searchParamsMap.has(name);
+    }
+    set(name, value) {
+        name = String(name);
+        value = String(value);
+        if (!this.has(name)) {
+            this.append(name, value);
+            return;
+        }
+        name = URLUtils.decodeUriComponent(name);
+        value = URLUtils.decodeUriComponent(value);
+        this._searchParamsMap.set(name, [value]);
+        const searchParamIdx = this._searchParamsArray.findIndex((param) => param[0] === name);
+        this._searchParamsArray[searchParamIdx][1] = value;
+        this._searchParamsArray = this._searchParamsArray.filter((param, idx) => param[0] !== name || idx === searchParamIdx);
+    }
+    toString() {
+        return this._searchParamsArray
+            .map(([key, value]) => `${URLUtils.encodeUriComponent(key)}=${URLUtils.encodeUriComponent(value)}`)
+            .join('&');
+    }
+    _constructSearchParamsFromString(init) {
+        let searchParams = String(init);
+        if (searchParams.startsWith('?')) {
+            searchParams = searchParams.slice(1);
+        }
+        searchParams.split('&').forEach((param) => {
+            let [key, value] = param.split('=');
+            if (!value) {
+                value = '';
+            }
+            this._saveParam(key, value);
+        });
+    }
+    _constructSearchParamsFromArray(init) {
+        for (const param of init) {
+            if (!Array.isArray(param || param.length !== 2)) {
+                throw new Error("Failed to construct 'UrlSearchParamsImpl'");
+            }
+            const key = String(param[0]);
+            const value = String(param[1]);
+            this._saveParam(key, value);
+        }
+    }
+    _constructSearchParamsFromObject(init) {
+        if (init instanceof Set) {
+            throw new Error("Failed to construct 'UrlSearchParamsImpl'");
+        }
+        for (const key of Object.keys(init)) {
+            const value = String(init[key]);
+            this._saveParam(key, value);
+        }
+    }
+    _saveParam(key, value) {
+        key = URLUtils.decodeUriComponent(key);
+        value = URLUtils.decodeUriComponent(value);
+        this._searchParamsArray.push([key, value]);
+        this._storeParamInSearchParamsMap(key, value);
+    }
+    _storeParamInSearchParamsMap(key, value) {
+        let values = this._searchParamsMap.get(key);
+        if (!values) {
+            values = [];
+            this._searchParamsMap.set(key, values);
+        }
+        values.push(value);
+    }
+}

package/lib/http/utils/index.d.ts

@@ -3,3 +3,9 @@ export * from './constants';
 export * from './HttpMethod';
 export * from './MinimalResponseUtils';
 export * from './MultipartFormDataUtils';
+export * from './FormDataImpl';
+export * from './MinimalResponseImpl';
+export * from './OutgoingRequestImpl';
+export * from './UrlImpl';
+export * from './UrlSearchParamsImpl';
+export * from './URLUtils';

package/lib/http/utils/index.js

@@ -3,3 +3,9 @@ export * from './constants';
 export * from './HttpMethod';
 export * from './MinimalResponseUtils';
 export * from './MultipartFormDataUtils';
+export * from './FormDataImpl';
+export * from './MinimalResponseImpl';
+export * from './OutgoingRequestImpl';
+export * from './UrlImpl';
+export * from './UrlSearchParamsImpl';
+export * from './URLUtils';

package/lib/{utils → impl}/base64/AtobBase64Utils.d.ts

@@ -1,4 +1,4 @@
-import { IBase64Utils } from './IBase64Utils';
+import { IBase64Utils } from '../../utils';
 export declare class AtobBase64Utils implements IBase64Utils {
     base64Decode(stringToDecode: string): string;
     base64Encode(stringToEncode: string): string;

package/lib/{utils → impl}/base64/BufferBase64Utils.d.ts

@@ -1,4 +1,4 @@
-import { IBase64Utils } from './IBase64Utils';
+import { IBase64Utils } from '../../utils';
 export declare class BufferBase64Utils implements IBase64Utils {
     static BASE_64_ENCODING: 'base64';
     base64Decode(stringToDecode: string): string;

package/lib/{utils → impl}/base64/BufferBase64Utils.js

@@ -1,4 +1,5 @@
 export class BufferBase64Utils {
+    static BASE_64_ENCODING = 'base64';
     base64Decode(stringToDecode) {
         const buffer = Buffer.from(stringToDecode, BufferBase64Utils.BASE_64_ENCODING);
         return buffer.toString('utf8');
@@ -8,4 +9,3 @@ export class BufferBase64Utils {
         return buffer.toString(BufferBase64Utils.BASE_64_ENCODING);
     }
 }
-BufferBase64Utils.BASE_64_ENCODING = 'base64';

package/lib/{utils → impl}/base64/JSBase64Base64Utils.d.ts

@@ -1,4 +1,4 @@
-import { IBase64Utils } from './IBase64Utils';
+import { IBase64Utils } from '../../utils';
 export declare class JSBase64Base64Utils implements IBase64Utils {
     base64Encode(stringToEncode: string): string;
     base64Decode(stringToDecode: string): string;

package/lib/{utils → impl}/cipher/CryptoCipherUtils.d.ts

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

package/lib/impl/cipher/CryptoCipherUtils.js

@@ -0,0 +1,18 @@
+import * as crypto from 'crypto';
+export class CryptoCipherUtils {
+    crypto;
+    constructor(cryptoModule = crypto) {
+        this.crypto = cryptoModule;
+    }
+    async pbkdf2Decrypt(secret, encryptedString, iterations, salt, options) {
+        const keylen = options?.keylen || 32;
+        const ivlen = options?.ivlen || 16;
+        const derivation = this.crypto.pbkdf2Sync(secret, Buffer.from(salt, 'base64'), iterations, keylen + ivlen, 'sha256');
+        const key = derivation.subarray(0, keylen);
+        const iv = derivation.subarray(keylen);
+        const cipher = this.crypto.createDecipheriv('aes-256-cbc', key, iv);
+        let decrypted = cipher.update(encryptedString, 'base64', 'utf8');
+        decrypted += cipher.final('utf8');
+        return decrypted;
+    }
+}

package/lib/{utils → impl}/cipher/SubtleCryptoCipherUtils.d.ts

@@ -1,5 +1,4 @@
-import { IBase64Utils } from '../base64';
-import { ICipherUtils, Pbkdf2DecryptOptions } from './ICipherUtils';
+import { ICipherUtils, IBase64Utils, Pbkdf2DecryptOptions } from '../../utils';
 export declare class SubtleCryptoCipherUtils implements ICipherUtils {
     private base64Utils;
     private subtleCrypto;

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

@@ -0,0 +1,17 @@
+import { EnrichedLogRecord, LogRecord } from './model';
+import { ReadonlyContext } from '../context';
+import { IConfiguration } from '../config';
+import { IHttpClient } from '../http';
+import { ILogger } from '../logger';
+import { ILogServiceClient } from './ILogServiceClient';
+export declare class HttpLogServiceClient<Req, Res> implements ILogServiceClient<Req, Res> {
+    protected readonly appId: string;
+    protected readonly backendUrl: string;
+    protected readonly loggerAuthToken: string;
+    protected readonly logger: ILogger;
+    protected readonly httpClient: IHttpClient;
+    constructor(config: IConfiguration<Req, Res>, httpClient: IHttpClient);
+    sendLogs(context: ReadonlyContext<Req, Res>, logs: LogRecord[]): Promise<void>;
+    protected enrichLogRecord(context: ReadonlyContext<Req, Res>, log: LogRecord): EnrichedLogRecord;
+    protected postLogs(logRecords: EnrichedLogRecord[]): Promise<boolean>;
+}

package/lib/logger/HttpLogServiceClient.js

@@ -0,0 +1,52 @@
+import { EXTERNAL_LOGGER_SERVICE_PATH } from './constants';
+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;
+        this.loggerAuthToken = config.loggerAuthToken;
+        this.logger = config.logger;
+        this.httpClient = httpClient;
+    }
+    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 = URLUtils.parseURL(requestData.rawUrl);
+        const logMeta = {
+            container: 'enforcer',
+            appID: this.appId,
+            method: requestData.method,
+            host: url.host,
+            url: requestData.rawUrl,
+            path: url.pathname + requestData.url.search,
+            requestId: context.requestId,
+        };
+        return { ...logMeta, ...log };
+    }
+    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/ILogServiceClient.d.ts

@@ -0,0 +1,6 @@
+import { ReadonlyContext } from '../context';
+import { LogRecord } from './model';
+import { AsyncOrSync } from 'ts-essentials';
+export interface ILogServiceClient<Req, Res> {
+    sendLogs(context: ReadonlyContext<Req, Res>, logs: LogRecord[]): AsyncOrSync<void>;
+}

package/lib/logger/ILogServiceClient.js

@@ -0,0 +1 @@
+export {};

package/lib/logger/ILogger.d.ts

@@ -1,4 +1,5 @@
 import { LoggerSeverity } from './LoggerSeverity';
+import { LogRecord } from './model';
 export interface ILogger {
     /**
      * @returns LoggerSeverity - The current logger severity.
@@ -21,4 +22,9 @@ export interface ILogger {
      * @returns void
      */
     error(message: string): void;
+    /**
+     * Get all the saved logs for that request
+     * @returns LogRecord[]
+     */
+    getLogs(): LogRecord[];
 }

package/lib/logger/LoggerBase.d.ts

@@ -1,8 +1,10 @@
 import { ILogger } from './ILogger';
 import { LoggerSeverity } from './LoggerSeverity';
+import { LogRecord } from './model';
 export declare abstract class LoggerBase implements ILogger {
-    private loggerSeverity;
-    protected constructor(loggerSeverity?: LoggerSeverity);
+    protected loggerSeverity: LoggerSeverity;
+    protected logs: LogRecord[];
+    protected constructor(loggerSeverity?: LoggerSeverity, logs?: LogRecord[]);
     protected abstract log(message: string): void;
     debug(message: string): void;
     error(message: string): void;
@@ -10,4 +12,6 @@ export declare abstract class LoggerBase implements ILogger {
     setLoggerSeverity(loggerSeverity: LoggerSeverity): void;
     protected logError(message: string): void;
     protected logDebug(message: string): void;
+    getLogs(): LogRecord[];
+    protected recordLog(message: string, loggerSeverity: LoggerSeverity): void;
 }

package/lib/logger/LoggerBase.js

@@ -1,14 +1,19 @@
 import { LoggerSeverity } from './LoggerSeverity';
 export class LoggerBase {
-    constructor(loggerSeverity = LoggerSeverity.ERROR) {
+    loggerSeverity;
+    logs;
+    constructor(loggerSeverity = LoggerSeverity.ERROR, logs = []) {
         this.loggerSeverity = loggerSeverity;
+        this.logs = logs;
     }
     debug(message) {
+        this.recordLog(message, LoggerSeverity.DEBUG);
         if (this.loggerSeverity == LoggerSeverity.DEBUG) {
             this.logDebug(message);
         }
     }
     error(message) {
+        this.recordLog(message, LoggerSeverity.ERROR);
         if (this.loggerSeverity != LoggerSeverity.NONE) {
             this.logError(message);
         }
@@ -27,4 +32,12 @@ export class LoggerBase {
     logDebug(message) {
         this.log(message);
     }
+    // default implementation, can be overridden
+    getLogs() {
+        return this.logs;
+    }
+    recordLog(message, loggerSeverity) {
+        const logRecord = { message: message, severity: loggerSeverity, messageTimestamp: Date.now() };
+        this.logs.push(logRecord);
+    }
 }

package/lib/logger/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const X_PX_ENFORCER_LOG_HEADER = "x-px-enforcer-log";
+export declare const EXTERNAL_LOGGER_SERVICE_PATH = "/enforcer-logs/";