perimeterx-js-core 0.6.2 → 0.7.1

package/lib/action/ActionData.d.ts

@@ -1,5 +1,5 @@
 import { Action } from './Action';
-export declare type ActionData = {
+export type ActionData = {
     /**
      * The recommended action that should be taken by the enforcer.
      */

package/lib/action/Decision.d.ts

@@ -1,6 +1,6 @@
 import { Action } from './index';
 import { ProductName } from '../products';
-export declare type Decision = {
+export type Decision = {
     action?: Action;
     reasons?: Partial<Record<ProductName, string>>;
 };

package/lib/action/ProductAction.d.ts

@@ -1,5 +1,5 @@
 import { ActionData } from './ActionData';
 import { ProductName } from '../products';
-export declare type ProductAction = ActionData & {
+export type ProductAction = ActionData & {
     productName: ProductName;
 };

package/lib/activities/model/Activity.d.ts

@@ -1,6 +1,6 @@
 import { ActivityType } from '../ActivityType';
 import { ActivityDetails } from './ActivityDetails';
-export declare type Activity = {
+export type Activity = {
     type: ActivityType;
     timestamp: number;
     socket_ip: string;

package/lib/activities/model/ActivityDetails.d.ts

@@ -1,7 +1,7 @@
 import { GraphQLData } from '../../graphql';
 import { BlockAction } from '../../blocker';
-export declare type ActivityTypeDetails = PageRequestedActivityDetails | BlockActivityDetails | AdditionalS2SActivityDetails;
-export declare type ActivityDetails = ActivityTypeDetails & {
+export type ActivityTypeDetails = PageRequestedActivityDetails | BlockActivityDetails | AdditionalS2SActivityDetails;
+export type ActivityDetails = ActivityTypeDetails & {
     client_uuid: string;
     request_id: string;
     module_version: string;
@@ -26,20 +26,20 @@ export declare type ActivityDetails = ActivityTypeDetails & {
     app_user_id?: string;
     jwt_additional_fields?: Record<string, any>;
 };
-export declare type PageRequestedActivityDetails = {
+export type PageRequestedActivityDetails = {
     pass_reason: string;
     px_cookie?: string;
     error_message?: string;
     s2s_error_reason?: string;
     s2s_error_http_status?: number;
 };
-export declare type BlockActivityDetails = {
+export type BlockActivityDetails = {
     block_reason: string;
     block_action: BlockAction;
     block_score: number;
     simulated_block: boolean;
 };
-export declare type AdditionalS2SActivityDetails = {
+export type AdditionalS2SActivityDetails = {
     http_status_code: number;
     login_successful: boolean;
     raw_username?: string;

package/lib/activities/utils.js

@@ -8,7 +8,7 @@ export const createActivity = (activityType, config, context) => {
     return {
         type: activityType,
         px_app_id: config.appId,
-        url: context.requestData.url.href,
+        url: context.requestData.rawUrl,
         headers: activityType !== ActivityType.ADDITIONAL_S2S
             ? joinHeaderValues(removeSensitiveHeaders(context.requestData.headers, config.sensitiveHeaders))
             : undefined,

package/lib/additional_activity_handler/AdditionalActivityHandler.d.ts

@@ -1,3 +1,3 @@
 import { ConfigurationParams } from '../config';
 import { ReadonlyContext } from '../context';
-export declare type AdditionalActivityHandler = <Req, Res>(config: ConfigurationParams<Req, Res>, context: ReadonlyContext<Req, Res>, request: Req) => void | Promise<void>;
+export type AdditionalActivityHandler = <Req, Res>(config: ConfigurationParams<Req, Res>, context: ReadonlyContext<Req, Res>, request: Req) => void | Promise<void>;

package/lib/config/ConfigurationParams.d.ts

@@ -5,7 +5,7 @@ import { CredentialEndpointConfiguration, CredentialIntelligenceVersion, CustomL
 import { LoggerSeverity } from '../logger';
 import { ModuleMode } from '../utils';
 import { GraphQLOperationType } from '../graphql';
-export declare type ConfigurationParams<Req, Res> = {
+export type ConfigurationParams<Req, Res> = {
     px_app_id: string;
     px_auth_token: string;
     px_cookie_secret: string;
@@ -73,6 +73,7 @@ export declare type ConfigurationParams<Req, Res> = {
     px_sensitive_graphql_operation_types?: Array<'query' | 'mutation' | 'subscription' | GraphQLOperationType>;
     px_cors_support_enabled?: boolean;
     px_cors_preflight_request_filter_enabled?: boolean;
+    px_logger_auth_token?: string;
     px_extract_ip?: () => {};
     px_additional_activity_handler?: AdditionalActivityHandler;
     px_enrich_custom_parameters?: CustomParametersFunction<Req, Res>;

package/lib/config/DefaultConfigurations.js

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

package/lib/config/IConfiguration.d.ts

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

package/lib/config/StaticConfigurationBase.d.ts

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

package/lib/config/StaticConfigurationBase.js

@@ -236,6 +236,9 @@ export class StaticConfigurationBase {
     get ciEnabled() {
         return this.configParams.px_login_credentials_extraction_enabled;
     }
+    get loggerAuthToken() {
+        return this.configParams.px_logger_auth_token;
+    }
     get ciEndpoints() {
         return this.configParams.px_login_credentials_extraction;
     }

package/lib/context/DefaultContext.d.ts

@@ -9,9 +9,11 @@ import { ICookieParser, IRequestIdGenerator, VidSource } from '../utils';
 import { IContext, RequestData, RiskApiData, ServerData, TlsData, TokenData } from './interfaces';
 import { ProductData, ProductName } from '../products';
 import { Action } from '../action';
-export declare type DefaultContextOptions = {
+import { IURLParser } from '../utils/url_parser';
+export type DefaultContextOptions = {
     cookieParser?: ICookieParser;
     requestIdGenerator: IRequestIdGenerator;
+    urlParser?: IURLParser;
 };
 export declare class DefaultContext<Req, Res> implements IContext<Req, Res> {
     readonly requestId: string;
@@ -35,6 +37,7 @@ export declare class DefaultContext<Req, Res> implements IContext<Req, Res> {
     customParameters?: CustomParameters;
     response?: IOutgoingResponse<Res>;
     protected readonly config: IConfiguration<Req, Res>;
+    protected readonly urlParser: IURLParser;
     constructor(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>, options: DefaultContextOptions);
     get isMobile(): boolean;
     protected createRequestData(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>, cookieParser?: ICookieParser): RequestData<Req>;

package/lib/context/DefaultContext.js

@@ -3,10 +3,12 @@ import { PXHDSource } from '../pxhd';
 import { TokenOrigin, TokenParseResult } from '../risk_token';
 import { RiskApiCallResult } from '../risk_api';
 import { COOKIE_HEADER_NAME, toReadonlyHeaders, USER_AGENT_HEADER_NAME, } from '../http';
-import { StringSplitCookieParser, getDecodedUrl, PXHD_COOKIE_NAME, PXVID_COOKIE_NAME, X_PX_AUTHORIZATION_HEADER_NAME, } from '../utils';
+import { StringSplitCookieParser, PXHD_COOKIE_NAME, PXVID_COOKIE_NAME, X_PX_AUTHORIZATION_HEADER_NAME, } from '../utils';
+import { DefaultUrlParser } from '../utils/url_parser';
 export class DefaultContext {
     constructor(config, request, options) {
         this.config = config;
+        this.urlParser = options.urlParser || new DefaultUrlParser();
         this.tokenData = {
             tokenParseResult: TokenParseResult.NONE,
         };
@@ -29,7 +31,8 @@ export class DefaultContext {
         return this.tokenOrigin === TokenOrigin.HEADER;
     }
     createRequestData(config, request, cookieParser = new StringSplitCookieParser()) {
-        const url = getDecodedUrl(request.url);
+        const rawUrl = request.url;
+        const url = this.urlParser.parse(rawUrl);
         const method = request.method;
         const headers = request.headers;
         const cookies = DefaultContext.getCookies(cookieParser, request.headers.get(COOKIE_HEADER_NAME), request.headers.get(config.customCookieHeader));
@@ -37,7 +40,7 @@ export class DefaultContext {
         const readOnlyHeaders = toReadonlyHeaders(headers);
         const userAgent = this.extractUserAgentFromHeader(config, readOnlyHeaders);
         const ip = this.extractIpFromHeader(config, readOnlyHeaders) || request.clientIP;
-        return { url, method, headers: readOnlyHeaders, cookies, ip, userAgent, requestCookieNames, request };
+        return { url, rawUrl, method, headers: readOnlyHeaders, cookies, ip, userAgent, requestCookieNames, request };
     }
     static getCookies(cookieParser, ...cookieHeaderValues) {
         const cookies = {};

package/lib/context/interfaces/MobileData.d.ts

@@ -1,5 +1,5 @@
 import { IToken, MobileError, TokenParseResult } from '../../risk_token';
-export declare type MobileData<Req, Res> = {
+export type MobileData<Req, Res> = {
     /**
      * The mobile error sent on the X-PX-Authorization header for mobile requests.
      */

package/lib/context/interfaces/ReadonlyContext.d.ts

@@ -1,3 +1,3 @@
 import { DeepReadonly } from 'ts-essentials';
 import { IContext } from './IContext';
-export declare type ReadonlyContext<Req, Res> = DeepReadonly<IContext<Req, Res>>;
+export type ReadonlyContext<Req, Res> = DeepReadonly<IContext<Req, Res>>;

package/lib/context/interfaces/RequestData.d.ts

@@ -1,9 +1,14 @@
 import { HttpMethod, IIncomingRequest, IURL, ReadonlyHeaders } from '../../http';
-export declare type RequestData<Req> = {
+export type RequestData<Req> = {
     /**
      * The request URL.
      */
     url: IURL;
+    /**
+     * The native url fetched from the environment.
+     * It should contain "..", duplicate slashes and un-decoded ascii characters (%XX) if possible.
+     */
+    rawUrl: string;
     /**
      * The request method, capitalized.
      */

package/lib/context/interfaces/RiskApiData.d.ts

@@ -1,5 +1,5 @@
 import { IRiskResponse, S2SErrorReason, RiskApiCallResult } from '../../risk_api';
-export declare type RiskApiData = {
+export type RiskApiData = {
     /**
      * The result of the risk API call.
      */

package/lib/context/interfaces/ServerData.d.ts

@@ -1,4 +1,4 @@
-export declare type ServerData = {
+export type ServerData = {
     /**
      * The operating system platform.
      */

package/lib/context/interfaces/TlsData.d.ts

@@ -1,4 +1,4 @@
-export declare type TlsData = {
+export type TlsData = {
     /**
      * The TLS version used for the HTTPS request (e.g., 1.2, 1.3).
      */

package/lib/context/interfaces/TokenData.d.ts

@@ -1,6 +1,6 @@
 import { IToken, TokenParseResult } from '../../risk_token';
 import { MobileData } from './MobileData';
-export declare type TokenData<Req, Res> = {
+export type TokenData<Req, Res> = {
     /**
      * The result of token parsing.
      */

package/lib/cors/CustomBlockResponseHeadersHandler.d.ts

@@ -1,2 +1,2 @@
 import { ReadonlyHeaders } from '../http';
-export declare type CustomBlockResponseHeadersHandler<Req> = (request: Req) => ReadonlyHeaders | Promise<ReadonlyHeaders>;
+export type CustomBlockResponseHeadersHandler<Req> = (request: Req) => ReadonlyHeaders | Promise<ReadonlyHeaders>;

package/lib/cors/CustomPreflightHandler.d.ts

@@ -1,2 +1,2 @@
 import { IMinimalResponse } from '../http';
-export declare type CustomPreflightHandler<Req> = (request: Req) => IMinimalResponse | Promise<IMinimalResponse>;
+export type CustomPreflightHandler<Req> = (request: Req) => IMinimalResponse | Promise<IMinimalResponse>;

package/lib/custom_parameters/CustomParameters.d.ts

@@ -1,4 +1,4 @@
-export declare type CustomParameters = {
+export type CustomParameters = {
     custom_param1?: any;
     custom_param2?: any;
     custom_param3?: any;

package/lib/custom_parameters/CustomParametersFunction.d.ts

@@ -1,3 +1,3 @@
 import { ConfigurationParams } from '../config';
 import { CustomParameters } from './CustomParameters';
-export declare type CustomParametersFunction<Req, Res> = (config: ConfigurationParams<Req, Res>, request: Req) => CustomParameters | Promise<CustomParameters>;
+export type CustomParametersFunction<Req, Res> = (config: ConfigurationParams<Req, Res>, request: Req) => CustomParameters | Promise<CustomParameters>;

package/lib/enforcer/EnforcerBase.d.ts

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

package/lib/enforcer/EnforcerBase.js

@@ -12,10 +12,11 @@ import { DefaultTelemetry } from '../telemetry';
 import { DefaultTokenV2Parser, DefaultTokenV3Parser, TokenVersion } from '../risk_token';
 import { DefaultCors } from '../cors';
 import { PostRiskApiClientV2, PostRiskApiClientV3 } from '../risk_api';
-import { EnforceFlow, FilterFlow, PostEnforceFlow } from '../phase';
+import { EndEnforcerFlow, EnforceFlow, FilterFlow, PostEnforceFlow } from '../phase';
 import { AccountDefender, BotDefender, CredentialIntelligence, ProductName } from '../products';
 import { HttpActivityClient, HttpBatchedActivityClient } from '../activities';
 import { DefaultGraphQLParser } from '../graphql';
+import { HttpLogServiceClient } from '../logger';
 export class EnforcerBase {
     /**
      * The EnforcerBase constructor.
@@ -30,6 +31,7 @@ export class EnforcerBase {
         this.filterFlow = new FilterFlow(config, initializationBlock);
         this.enforceFlow = new EnforceFlow(config, initializationBlock);
         this.postEnforceFlow = new PostEnforceFlow(config, initializationBlock);
+        this.endEnforcerFlow = new EndEnforcerFlow(config, initializationBlock);
     }
     /**
      * The central function that triggers enforcement on the incoming request.
@@ -62,11 +64,16 @@ export class EnforcerBase {
             const context = yield this.constructContext(...args);
             let result = yield this.filterFlow.execute(context);
             if (result.done) {
-                return result.response ? this.convertToRes(result.response) : null;
+                yield this.endEnforcerFlow.execute(context);
+                return result.response ? this.convertToRes(result.response, ...args) : null;
             }
             this.preserveContext(context, ...args);
             result = yield this.enforceFlow.execute(context);
-            return result.response ? this.convertToRes(result.response) : null;
+            if (result.response) {
+                yield this.endEnforcerFlow.execute(context);
+                return this.convertToRes(result.response, ...args);
+            }
+            return null;
         });
     }
     /**
@@ -83,6 +90,7 @@ export class EnforcerBase {
                     context.response = yield this.convertToOutgoingResponse(...args);
                     yield this.postEnforceFlow.execute(context);
                 }
+                yield this.endEnforcerFlow.execute(context);
             }
             catch (e) {
                 this.config.logger.error(`caught error in post enforce - ${e}`);
@@ -124,6 +132,7 @@ export class EnforcerBase {
             (config.maxActivityBatchSize > 1
                 ? new HttpBatchedActivityClient(config, httpClient)
                 : new HttpActivityClient(config, httpClient));
+        const logServiceClient = options.logServiceClient || (config.loggerAuthToken ? new HttpLogServiceClient(config, httpClient) : null);
         const allOptions = {
             httpClient,
             base64Utils,
@@ -137,6 +146,7 @@ export class EnforcerBase {
             tokenParser,
             riskApiClient,
             activityClient,
+            logServiceClient,
         };
         const products = this.initializeProducts(config, options.products, base64Utils, hashUtils, ipRangeChecker);
         return Object.assign({ products }, allOptions);

package/lib/enforcer/options/EnforcerBaseOptions.d.ts

@@ -8,7 +8,8 @@ import { IRiskApiClient } from '../../risk_api';
 import { IActivityClient } from '../../activities';
 import { Products } from '../../products';
 import { IGraphQLParser } from '../../graphql';
-export declare type EnforcerBaseOptions<Req, Res> = {
+import { ILogServiceClient } from '../../logger';
+export type EnforcerBaseOptions<Req, Res> = {
     httpClient: IHttpClient;
     base64Utils: IBase64Utils;
     hmacUtils: IHmacUtils;
@@ -22,4 +23,5 @@ export declare type EnforcerBaseOptions<Req, Res> = {
     telemetry?: ITelemetry<Req, Res>;
     riskApiClient?: IRiskApiClient<Req, Res>;
     activityClient?: IActivityClient<Req, Res>;
+    logServiceClient?: ILogServiceClient<Req, Res>;
 };

package/lib/enforcer/options/EnforcerOptionsType.d.ts

@@ -1,4 +1,4 @@
 import { TokenVersion } from '../../risk_token';
 import { EnforcerV2Options } from './EnforcerV2Options';
 import { EnforcerV3Options } from './EnforcerV3Options';
-export declare type EnforcerOptionsType<TokenV extends TokenVersion, Req, Res> = TokenV extends TokenVersion.V2 ? EnforcerV2Options<Req, Res> : TokenV extends TokenVersion.V3 ? EnforcerV3Options<Req, Res> : never;
+export type EnforcerOptionsType<TokenV extends TokenVersion, Req, Res> = TokenV extends TokenVersion.V2 ? EnforcerV2Options<Req, Res> : TokenV extends TokenVersion.V3 ? EnforcerV3Options<Req, Res> : never;

package/lib/enforcer/options/EnforcerV2Options.d.ts

@@ -1,5 +1,5 @@
 import { TokenVersion } from '../../risk_token';
 import { EnforcerBaseOptions } from './EnforcerBaseOptions';
-export declare type EnforcerV2Options<Req, Res> = {
+export type EnforcerV2Options<Req, Res> = {
     tokenVersion: TokenVersion.V2;
 } & EnforcerBaseOptions<Req, Res>;

package/lib/enforcer/options/EnforcerV3Options.d.ts

@@ -1,7 +1,7 @@
 import { TokenVersion } from '../../risk_token';
 import { ICipherUtils } from '../../utils';
 import { EnforcerBaseOptions } from './EnforcerBaseOptions';
-export declare type EnforcerV3Options<Req, Res> = {
+export type EnforcerV3Options<Req, Res> = {
     tokenVersion: TokenVersion.V3;
     cipherUtils: ICipherUtils;
 } & EnforcerBaseOptions<Req, Res>;

package/lib/first_party/FirstPartyData.d.ts

@@ -1,5 +1,5 @@
 import { IMinimalResponse, IOutgoingRequest } from '../http';
-export declare type FirstPartyData = {
+export type FirstPartyData = {
     request?: IOutgoingRequest;
     defaultResponse: IMinimalResponse;
 };

package/lib/graphql/model/GraphQLData.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLOperationType } from './GraphQLOperationType';
-export declare type GraphQLData = {
+export type GraphQLData = {
     type: GraphQLOperationType;
     name?: string;
     sensitive?: boolean;

package/lib/graphql/model/GraphQLOperation.d.ts

@@ -1,4 +1,4 @@
-export declare type GraphQLOperation = {
+export type GraphQLOperation = {
     query: string;
     operationName?: string;
     variables?: Record<string, unknown>;

package/lib/http/impl/FormDataImpl.js

@@ -29,8 +29,8 @@ export class FormDataImpl {
         if (typeof value === 'string') {
             this.data[name] = [value];
         }
-        else {
-            this.data[name] = [Object.assign(Object.assign({}, value), { name: filename !== null && filename !== void 0 ? filename : '', lastModified: Date.now(), webkitRelativePath: '' })];
+        else if (File) {
+            this.data[name] = [new File([value], filename)];
         }
     }
 }

package/lib/http/impl/MinimalResponseImpl.d.ts

@@ -1,6 +1,6 @@
 import { IMinimalResponse } from '../interfaces';
 import { ReadonlyHeaders } from '../interfaces';
-export declare type MinimalResponseOptions = {
+export type MinimalResponseOptions = {
     status?: number;
     headers?: ReadonlyHeaders;
     body: any;

package/lib/http/impl/OutgoingRequestImpl.d.ts

@@ -1,5 +1,5 @@
 import { ReadonlyHeaders, HttpMethod, IOutgoingRequest } from '..';
-export declare type OutGoingRequestImplOptions = {
+export type OutGoingRequestImplOptions = {
     url: string;
     method?: HttpMethod | string;
     headers?: ReadonlyHeaders;

package/lib/http/interfaces/IHttpClient.d.ts

@@ -1,7 +1,7 @@
 import { AsyncOrSync } from 'ts-essentials';
 import { IOutgoingRequest } from './IOutgoingRequest';
 import { IIncomingResponse } from './IIncomingResponse';
-export declare type HttpSendOptions = {
+export type HttpSendOptions = {
     timeoutMs?: number;
 };
 export interface IHttpClient {

package/lib/http/interfaces/ReadonlyHeaders.d.ts

@@ -1,6 +1,6 @@
 import { DeepReadonly } from 'ts-essentials';
 import { IHeaders } from './IHeaders';
-export declare type ReadonlyHeaders = DeepReadonly<Record<string, string[]>>;
+export type ReadonlyHeaders = DeepReadonly<Record<string, string[]>>;
 export declare const toReadonlyHeaders: (headers: IHeaders) => ReadonlyHeaders;
 export declare const toMutableHeaders: (headers: ReadonlyHeaders) => Record<string, string[]>;
 export declare const joinHeaderValues: (headers: ReadonlyHeaders) => Record<string, string>;

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,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 { EXTERNAL_LOGGER_SERVICE_PATH } from './constants';
+import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../http';
+import { getAuthorizationHeader } from '../utils';
+export class HttpLogServiceClient {
+    constructor(config, httpClient) {
+        this.appId = config.appId;
+        this.backendUrl = config.backendScoreApiUrl;
+        this.loggerAuthToken = config.loggerAuthToken;
+        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}`);
+            }
+        });
+    }
+    enrichLogRecord(context, log) {
+        const requestData = context.requestData;
+        const url = new URL(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 Object.assign(Object.assign({}, 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;
+        });
+    }
+}

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;
 }