perimeterx-js-core 0.15.2 → 0.16.0

package/lib/types/blocker/utils.d.ts

@@ -4,6 +4,14 @@ import { IBase64Utils } from '../utils';
 import { BlockData } from './model';
 export declare const renderHtml: (htmlTemplate: string, blockData?: BlockData) => string;
 export declare const createBlockData: <Req, Res>(config: IConfiguration<Req, Res, import("../config").ConfigurationParams<Req, Res>>, context: {
+    readonly logger: {
+        readonly getLoggerSeverity: () => import("..").LoggerSeverity;
+        readonly setLoggerSeverity: (loggerSeverity: import("..").LoggerSeverity) => void;
+        readonly debug: (message: string, metadata?: Record<string, any>) => void;
+        readonly error: (message: string, metadata?: Record<string, any>) => void;
+        readonly getLogs: () => import("..").LogRecord[];
+        readonly clearLogs: () => void;
+    };
     readonly requestId: string;
     readonly isMobile: boolean;
     readonly requestData: {
@@ -68,6 +76,14 @@ export declare const createBlockData: <Req, Res>(config: IConfiguration<Req, Res
             readonly score: number;
             readonly cpa: boolean;
             readonly verify: (context: {
+                readonly logger: {
+                    readonly getLoggerSeverity: () => import("..").LoggerSeverity;
+                    readonly setLoggerSeverity: (loggerSeverity: import("..").LoggerSeverity) => void;
+                    readonly debug: (message: string, metadata?: Record<string, any>) => void;
+                    readonly error: (message: string, metadata?: Record<string, any>) => void;
+                    readonly getLogs: () => import("..").LogRecord[];
+                    readonly clearLogs: () => void;
+                };
                 readonly requestId: string;
                 readonly isMobile: boolean;
                 readonly requestData: {
@@ -265,6 +281,7 @@ export declare const createBlockData: <Req, Res>(config: IConfiguration<Req, Res
                     readonly getUnderlyingResponse: () => Res;
                 };
                 readonly shouldSendLogs: boolean;
+                readonly isRemoteConfigUpdateRequest: boolean;
                 readonly enforcerStartTime?: number;
             }) => import("ts-essentials").AsyncOrSync<import("..").TokenParseResult>;
             readonly isExpired: () => boolean;
@@ -284,6 +301,14 @@ export declare const createBlockData: <Req, Res>(config: IConfiguration<Req, Res
                 readonly score: number;
                 readonly cpa: boolean;
                 readonly verify: (context: {
+                    readonly logger: {
+                        readonly getLoggerSeverity: () => import("..").LoggerSeverity;
+                        readonly setLoggerSeverity: (loggerSeverity: import("..").LoggerSeverity) => void;
+                        readonly debug: (message: string, metadata?: Record<string, any>) => void;
+                        readonly error: (message: string, metadata?: Record<string, any>) => void;
+                        readonly getLogs: () => import("..").LogRecord[];
+                        readonly clearLogs: () => void;
+                    };
                     readonly requestId: string;
                     readonly isMobile: boolean;
                     readonly requestData: {
@@ -481,6 +506,7 @@ export declare const createBlockData: <Req, Res>(config: IConfiguration<Req, Res
                         readonly getUnderlyingResponse: () => Res;
                     };
                     readonly shouldSendLogs: boolean;
+                    readonly isRemoteConfigUpdateRequest: boolean;
                     readonly enforcerStartTime?: number;
                 }) => import("ts-essentials").AsyncOrSync<import("..").TokenParseResult>;
                 readonly isExpired: () => boolean;
@@ -637,5 +663,6 @@ export declare const createBlockData: <Req, Res>(config: IConfiguration<Req, Res
         readonly getUnderlyingResponse: () => Res;
     };
     readonly shouldSendLogs: boolean;
+    readonly isRemoteConfigUpdateRequest: boolean;
     readonly enforcerStartTime?: number;
 }, base64Utils: IBase64Utils) => BlockData;

package/lib/types/config/ConfigurationBase.d.ts

@@ -12,11 +12,12 @@ export declare abstract class ConfigurationBase<Req, Res, ParamsType extends Con
     protected internalLogger: ILogger;
     protected abstract getModuleVersion(): string;
     protected constructor(params: ParamsType, defaultParams?: Partial<ParamsType>);
-    private initialize;
-    private throwIfMissingRequiredField;
-    private getValidConfigValue;
-    private isValidConfigValue;
-    private getDefaultConfigurationValue;
+    protected initialize(params: ParamsType, defaultParams: ParamsType): ParamsType;
+    protected throwIfMissingRequiredField(params: ParamsType): void;
+    protected getValidConfigValue<K extends keyof ParamsType, V extends ParamsType[K]>(params: ParamsType, defaultParams: ParamsType, key: K): V;
+    protected isValidConfigValue(params: ParamsType, defaultParams: ParamsType, key: keyof ParamsType): boolean;
+    protected getDefaultConfigurationValue<K extends keyof ParamsType, V extends ParamsType[K]>(params: ParamsType, defaultParams: ParamsType, key: K): V;
+    protected createInternalLogger(loggerSeverity: LoggerSeverity): ILogger;
     toParams(): ParamsType;
     get moduleVersion(): string;
     get logger(): ILogger;

package/lib/types/config/remote_config/DefaultRemoteConfigUpdater.d.ts

@@ -25,11 +25,11 @@ export declare class DefaultRemoteConfigUpdater<Req, Res, ParamsType extends Con
     protected readonly storageClient: IRemoteConfigStorageClient<Req, Res>;
     protected readonly timestampHmacHeaderValidator: ITimestampHmacHeaderValidator;
     constructor(config: IConfiguration<Req, Res, ParamsType>, options: DefaultRemoteConfigUpdaterOptions<Req, Res>);
-    isUpdateRemoteConfigRequest({ requestData: { request } }: ReadonlyContext<Req, Res>): boolean;
-    updateRemoteConfig({ requestData: { request } }: ReadonlyContext<Req, Res>): Promise<boolean>;
-    protected isUpdateRequestValid(request: IIncomingRequest<Req>): Promise<boolean>;
-    protected getUpdateRequestData(request: IIncomingRequest<Req>): Promise<RemoteConfigUpdateRequestData>;
-    protected fetchRemoteConfig(updateRequestData: RemoteConfigUpdateRequestData): Promise<RemoteConfigData<Req, Res> | null>;
+    isUpdateRemoteConfigRequest(context: ReadonlyContext<Req, Res>): boolean;
+    updateRemoteConfig(context: ReadonlyContext<Req, Res>): Promise<boolean>;
+    protected isUpdateRequestValid(request: IIncomingRequest<Req>, context: ReadonlyContext<Req, Res>): Promise<boolean>;
+    protected getUpdateRequestData(request: IIncomingRequest<Req>, context: ReadonlyContext<Req, Res>): Promise<RemoteConfigUpdateRequestData>;
+    protected fetchRemoteConfig(updateRequestData: RemoteConfigUpdateRequestData, context: ReadonlyContext<Req, Res>): Promise<RemoteConfigData<Req, Res> | null>;
     protected isDesiredRemoteConfigVersion({ version }: RemoteConfigUpdateRequestData, remoteConfigData: RemoteConfigData<Req, Res>): boolean;
     protected sleepBetweenFetchAttempts(ms: number): Promise<void>;
 }

package/lib/types/config/remote_config/RemoteConfigUtils.d.ts

@@ -0,0 +1,4 @@
+import { IIncomingRequest } from '../../http';
+export declare namespace RemoteConfigUtils {
+    const isRemoteConfigUpdateRequest: <Req>(request: IIncomingRequest<Req>) => boolean;
+}

package/lib/types/config/remote_config/index.d.ts

@@ -4,3 +4,4 @@ export * from './service_client';
 export * from './storage_client';
 export * from './DefaultRemoteConfigUpdater';
 export * from './IRemoteConfigUpdater';
+export * from './RemoteConfigUtils';

package/lib/types/context/DefaultContext.d.ts

@@ -8,6 +8,7 @@ import { IIncomingRequest, IOutgoingResponse, ReadonlyHeaders } from '../http';
 import { ICookieParser, IRequestIdGenerator, IUrl, IUrlUtils, VidSource } from '../utils';
 import { ProductData, ProductName } from '../products';
 import { Action } from '../action';
+import { ILogger } from '../logger';
 import { IContext, RequestData, RiskApiData, ServerData, TlsData, TokenData } from './interfaces';
 export type DefaultContextOptions = {
     cookieParser?: ICookieParser;
@@ -17,6 +18,8 @@ export type DefaultContextOptions = {
 export declare class DefaultContext<Req, Res> implements IContext<Req, Res> {
     readonly requestId: string;
     readonly tokenOrigin: TokenOrigin;
+    readonly isRemoteConfigUpdateRequest: boolean;
+    readonly shouldSendLogs: boolean;
     readonly requestData: RequestData<Req>;
     readonly tokenData: TokenData<Req, Res>;
     readonly riskApiData: RiskApiData;
@@ -30,7 +33,6 @@ export declare class DefaultContext<Req, Res> implements IContext<Req, Res> {
     reasons?: Partial<Record<ProductName, string>>;
     score?: number;
     blockAction?: BlockAction;
-    shouldSendLogs: boolean;
     pxhd?: PXHD;
     pxde?: PXDE;
     pxdeVerified?: boolean;
@@ -39,8 +41,11 @@ export declare class DefaultContext<Req, Res> implements IContext<Req, Res> {
     enforcerStartTime?: number;
     protected readonly config: IConfiguration<Req, Res>;
     protected readonly urlUtils: IUrlUtils;
+    protected readonly contextLogger: ILogger;
     constructor(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>, options: DefaultContextOptions);
+    get logger(): ILogger;
     get isMobile(): boolean;
+    protected createContextLogger(config: IConfiguration<Req, Res>, shouldSaveLogs: boolean): ILogger;
     protected createRequestData(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>, cookieParser?: ICookieParser): RequestData<Req>;
     protected static getCookies(cookieParser: ICookieParser, ...cookieHeaderValues: string[]): Record<string, string>;
     protected normalizeUrl(rawUrl: string): IUrl;
@@ -48,5 +53,5 @@ export declare class DefaultContext<Req, Res> implements IContext<Req, Res> {
     protected extractIpFromHeader(config: IConfiguration<Req, Res>, headers: ReadonlyHeaders): string;
     protected getTokenOrigin(request: IIncomingRequest<Req>): TokenOrigin;
     protected setCookiesOnContext(): void;
-    protected isHeaderBasedLoggerEnabled(): boolean;
+    protected isHeaderBasedLoggerRequest(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>): boolean;
 }

package/lib/types/context/interfaces/IContext.d.ts

@@ -13,7 +13,12 @@ import { Action } from '../../action';
 import { IOutgoingResponse } from '../../http';
 import { GraphQLData } from '../../graphql';
 import { PXHD } from '../../pxhd';
+import { ILogger } from '../../logger';
 export interface IContext<Req, Res> {
+    /**
+     * Logger for recording messages related to the request flow.
+     */
+    readonly logger: ILogger;
     /**
      * A UUID generated in the enforcer unique to each HTTP request.
      */
@@ -111,9 +116,13 @@ export interface IContext<Req, Res> {
     /**
      * Whether to send the logs for the current request to the logger service.
      */
-    shouldSendLogs: boolean;
+    readonly shouldSendLogs: boolean;
+    /**
+     * Whether the incoming request was sent to trigger a remote configuration update.
+     */
+    readonly isRemoteConfigUpdateRequest: boolean;
     /**
      * The time the Enforcer process started
      */
-    enforcerStartTime?: number;
+    readonly enforcerStartTime?: number;
 }

package/lib/types/enforcer/EnforcerBase.d.ts

@@ -71,11 +71,12 @@ export declare abstract class EnforcerBase<TokenV extends TokenVersion, Req, Res
     enforce(...args: EnforceArgs): Promise<Res | null>;
     /**
      * Performs all enforcer functionality on the incoming request context.
+     * @param context
      * @param args - The EnforceArgs required to enforce the incoming request.
      * @returns Promise<Res|null> -  A Promise resolving to a Res or null depending on the action that should be taken.
      * @protected
      */
-    protected doEnforce(...args: EnforceArgs): Promise<Res | null>;
+    protected doEnforce(context: IContext<Req, Res>, ...args: EnforceArgs): Promise<Res | null>;
     /**
      * Performs all required functionality after an origin response has been received.
      * @param args - The PostEnforce args required to enforce the incoming request.

package/lib/types/graphql/DefaultGraphQLParser.d.ts

@@ -3,13 +3,12 @@ import { IConfiguration } from '../config';
 import { IGraphQLParser } from './IGraphQLParser';
 import { GraphQLData } from './model';
 export declare class DefaultGraphQLParser<Req, Res> implements IGraphQLParser<Req, Res> {
-    private readonly config;
     private readonly graphqlRoutes;
     private readonly sensitiveOperationTypes;
     private readonly sensitiveOperationNames;
     constructor(config: IConfiguration<Req, Res>);
     isGraphQLRequest({ requestData }: ReadonlyContext<Req, Res>): boolean;
-    parseGraphQLRequest({ requestData }: ReadonlyContext<Req, Res>): Promise<GraphQLData[]>;
+    parseGraphQLRequest(context: ReadonlyContext<Req, Res>): Promise<GraphQLData[]>;
     private getGraphQLOperationsFromBody;
     private parseGraphQLOperations;
     private parseGraphQlOperation;

package/lib/types/logger/DefaultLogger.d.ts

@@ -2,6 +2,6 @@ import { LoggerSeverity } from './LoggerSeverity';
 import { LoggerBase } from './LoggerBase';
 import { ILogger } from './ILogger';
 export declare class DefaultLogger extends LoggerBase implements ILogger {
-    constructor(loggerSeverity: LoggerSeverity);
+    constructor(loggerSeverity: LoggerSeverity, shouldSaveLogs: boolean);
     protected log(message: string): void;
 }

package/lib/types/logger/HttpLogServiceClient.d.ts

@@ -1,19 +1,14 @@
-import { EnrichedLogRecord, LogRecord } from './model';
+import { EnrichedLogRecord, LogMetadata, 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 remoteConfigId: string;
-    protected readonly remoteConfigVersion: number;
-    protected readonly logger: ILogger;
+    protected readonly config: IConfiguration<Req, Res>;
     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;
+    sendLogs(context: ReadonlyContext<Req, Res>): Promise<void>;
+    protected getLogMetadata(context: ReadonlyContext<Req, Res>): LogMetadata;
+    protected enrichLogRecord(log: LogRecord, logMetadata: LogMetadata): EnrichedLogRecord;
     protected postLogs(logRecords: EnrichedLogRecord[]): Promise<boolean>;
 }

package/lib/types/logger/ILogServiceClient.d.ts

@@ -1,6 +1,5 @@
 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>;
+    sendLogs(context: ReadonlyContext<Req, Res>): AsyncOrSync<void>;
 }

package/lib/types/logger/LoggerBase.d.ts

@@ -3,8 +3,9 @@ import { LoggerSeverity } from './LoggerSeverity';
 import { LogRecord } from './model';
 export declare abstract class LoggerBase implements ILogger {
     protected loggerSeverity: LoggerSeverity;
+    protected readonly shouldSaveLogs: boolean;
     protected logs: LogRecord[];
-    protected constructor(loggerSeverity?: LoggerSeverity, logs?: LogRecord[]);
+    protected constructor(loggerSeverity: LoggerSeverity, shouldSaveLogs: boolean, logs?: LogRecord[]);
     protected abstract log(message: string): void;
     debug(message: string, metadata?: Record<string, any>): void;
     error(message: string, metadata?: Record<string, any>): void;

package/lib/types/logger/model/LogMetadata.d.ts

@@ -5,6 +5,7 @@ export type LogMetadata = {
     host: string;
     url: string;
     path: string;
+    moduleVersion: string;
     requestId: string;
     remoteConfigID?: string;
     remoteConfigVersion?: number;