perimeterx-js-core 0.7.0 → 0.8.0

package/lib/action/utils.js

@@ -5,7 +5,7 @@ export const getDecisionFromContext = (context) => {
 };
 export const getProductActions = (context) => {
     return Object.entries(context.productData)
-        .filter(([_, data]) => (data === null || data === void 0 ? void 0 : data.action) != null && (data === null || data === void 0 ? void 0 : data.reason) != null)
+        .filter(([_, data]) => data?.action != null && data?.reason != null)
         .map(([productName, data]) => ({
         action: data.action,
         reason: data.reason,

package/lib/activities/HttpActivityClient.d.ts

@@ -2,19 +2,19 @@ import { IConfiguration } from '../config';
 import { ReadonlyContext } from '../context';
 import { IHttpClient } from '../http';
 import { IActivityClient } from './IActivityClient';
-import { Activity } from './model';
+import { AsyncActivity } from './model';
 export declare class HttpActivityClient<Req, Res> implements IActivityClient<Req, Res> {
     private readonly config;
     private readonly httpClient;
     constructor(config: IConfiguration<Req, Res>, httpClient: IHttpClient);
     sendActivities(context: ReadonlyContext<Req, Res>): Promise<boolean>;
-    protected createActivities(context: ReadonlyContext<Req, Res>): Activity[];
+    protected createActivities(context: ReadonlyContext<Req, Res>): AsyncActivity[];
     /**
      * Allows for expansions or alterations to the async activity if needed.
      * @param activity
-     * @returns Activity
+     * @returns AsyncActivity
      * @protected
      */
-    protected finalizeActivity(activity: Activity): Activity;
-    protected postActivities(activities: Activity[]): Promise<boolean>;
+    protected finalizeActivity(activity: AsyncActivity): AsyncActivity;
+    protected postActivities(activities: AsyncActivity[]): Promise<boolean>;
 }

package/lib/activities/HttpActivityClient.js

@@ -1,44 +1,35 @@
-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 { Action } from '../action';
 import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../http';
 import { getAuthorizationHeader } from '../utils';
 import { ActivityType } from './ActivityType';
-import { createActivity } from './utils';
+import { createAsyncActivity } from './utils';
 import { ACTIVITIES_ENDPOINT } from './constants';
 export class HttpActivityClient {
+    config;
+    httpClient;
     constructor(config, httpClient) {
         this.config = config;
         this.httpClient = httpClient;
     }
-    sendActivities(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const activities = this.createActivities(context);
-                return yield this.postActivities(activities);
-            }
-            catch (e) {
-                this.config.logger.error(`unable to send activities - ${e}`);
-                return false;
-            }
-        });
+    async sendActivities(context) {
+        try {
+            const activities = this.createActivities(context);
+            return await this.postActivities(activities);
+        }
+        catch (e) {
+            this.config.logger.error(`unable to send activities - ${e}`);
+            return false;
+        }
     }
     createActivities(context) {
         const activities = [];
         if (context.action === Action.BLOCK || context.action === Action.SIMULATED_BLOCK) {
-            activities.push(createActivity(ActivityType.BLOCK, this.config, context));
+            activities.push(createAsyncActivity(ActivityType.BLOCK, this.config, context));
         }
         else if (context.action === Action.PASS_REQUEST) {
-            activities.push(createActivity(ActivityType.PAGE_REQUESTED, this.config, context));
+            activities.push(createAsyncActivity(ActivityType.PAGE_REQUESTED, this.config, context));
             if (context.productData.ci && this.config.ciAutomaticAdditionalS2SEnabled) {
-                activities.push(createActivity(ActivityType.ADDITIONAL_S2S, this.config, context));
+                activities.push(createAsyncActivity(ActivityType.ADDITIONAL_S2S, this.config, context));
             }
         }
         return activities.map(this.finalizeActivity);
@@ -46,25 +37,23 @@ export class HttpActivityClient {
     /**
      * Allows for expansions or alterations to the async activity if needed.
      * @param activity
-     * @returns Activity
+     * @returns AsyncActivity
      * @protected
      */
     finalizeActivity(activity) {
         return activity;
     }
-    postActivities(activities) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const url = `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`;
-            const method = HttpMethod.POST;
-            const headers = {
-                [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
-                [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
-            };
-            const body = activities.length === 1 ? JSON.stringify(activities[0]) : JSON.stringify(activities);
-            this.config.logger.debug(`sending ${activities.map(({ type }) => `${type} activity`).join(', ')} to ${url}`);
-            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 postActivities(activities) {
+        const url = `${this.config.backendCollectorUrl}${ACTIVITIES_ENDPOINT}`;
+        const method = HttpMethod.POST;
+        const headers = {
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+            [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
+        };
+        const body = activities.length === 1 ? JSON.stringify(activities[0]) : JSON.stringify(activities);
+        this.config.logger.debug(`sending ${activities.map(({ type }) => `${type} activity`).join(', ')} to ${url}`);
+        const req = new OutgoingRequestImpl({ url, method, headers, body });
+        const res = await this.httpClient.send(req);
+        return res?.status === 200;
     }
 }

package/lib/activities/HttpBatchedActivityClient.d.ts

@@ -1,6 +1,6 @@
 import { HttpActivityClient } from './HttpActivityClient';
 import { IConfiguration } from '../config';
-import { Activity } from './model/Activity';
+import { AsyncActivity } from './model/AsyncActivity';
 import { IHttpClient } from '../http';
 export declare class HttpBatchedActivityClient<Req, Res> extends HttpActivityClient<Req, Res> {
     private readonly batchSize;
@@ -10,7 +10,7 @@ export declare class HttpBatchedActivityClient<Req, Res> extends HttpActivityCli
     private timeoutId;
     constructor(config: IConfiguration<Req, Res>, httpClient: IHttpClient);
     stop(): void;
-    protected postActivities(activities: Activity[]): Promise<boolean>;
+    protected postActivities(activities: AsyncActivity[]): Promise<boolean>;
     private addToBuffer;
     private shouldFlush;
     protected triggerFlush(): Promise<boolean>;

package/lib/activities/HttpBatchedActivityClient.js

@@ -1,14 +1,10 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { HttpActivityClient } from './HttpActivityClient';
 export class HttpBatchedActivityClient extends HttpActivityClient {
+    batchSize;
+    timeoutMs;
+    maxBufferSize;
+    buffer;
+    timeoutId;
     constructor(config, httpClient) {
         super(config, httpClient);
         this.buffer = [];
@@ -20,11 +16,9 @@ export class HttpBatchedActivityClient extends HttpActivityClient {
     stop() {
         this.stopTimer();
     }
-    postActivities(activities) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.addToBuffer(activities);
-            return this.shouldFlush() ? this.triggerFlush() : true;
-        });
+    async postActivities(activities) {
+        this.addToBuffer(activities);
+        return this.shouldFlush() ? this.triggerFlush() : true;
     }
     addToBuffer(activities) {
         this.buffer = activities.concat(this.buffer);
@@ -35,25 +29,18 @@ export class HttpBatchedActivityClient extends HttpActivityClient {
     shouldFlush() {
         return this.buffer.length >= this.batchSize;
     }
-    triggerFlush() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.stopTimer();
-            const sentSuccessfully = this.buffer.length > 0 && (yield this.flush());
-            this.startTimer();
-            return sentSuccessfully;
-        });
+    async triggerFlush() {
+        this.stopTimer();
+        const sentSuccessfully = this.buffer.length > 0 && (await this.flush());
+        this.startTimer();
+        return sentSuccessfully;
     }
-    flush() {
-        const _super = Object.create(null, {
-            postActivities: { get: () => super.postActivities }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const sentSuccessfully = yield _super.postActivities.call(this, this.buffer);
-            if (sentSuccessfully) {
-                this.clear();
-            }
-            return sentSuccessfully;
-        });
+    async flush() {
+        const sentSuccessfully = await super.postActivities(this.buffer);
+        if (sentSuccessfully) {
+            this.clear();
+        }
+        return sentSuccessfully;
     }
     clear() {
         this.buffer = [];

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

@@ -0,0 +1,14 @@
+import { ActivityType } from '../ActivityType';
+import { AsyncActivityDetails } from './AsyncActivityDetails';
+import { HeaderEntry } from './HeaderEntry';
+export type AsyncActivity = {
+    type: ActivityType;
+    timestamp: number;
+    socket_ip: string;
+    url: string;
+    px_app_id: string;
+    headers?: HeaderEntry[];
+    vid?: string;
+    pxhd?: string;
+    details: AsyncActivityDetails;
+};

package/lib/activities/model/{ActivityDetails.d.ts → AsyncActivityDetails.d.ts}

@@ -1,34 +1,17 @@
-import { GraphQLData } from '../../graphql';
 import { BlockAction } from '../../blocker';
-export type ActivityTypeDetails = PageRequestedActivityDetails | BlockActivityDetails | AdditionalS2SActivityDetails;
-export type ActivityDetails = ActivityTypeDetails & {
+import { CommonActivityDetails } from './CommonActivityDetails';
+import { RiskAdditionalData } from '../../risk_api';
+export type AsyncActivityDetails = ActivityTypeDetails & AsyncActivityCommonDetails & CommonActivityDetails;
+export type AsyncActivityCommonDetails = Partial<RiskAdditionalData> & {
     client_uuid: string;
-    request_id: string;
-    module_version: string;
-    cookie_origin: string;
-    http_method: string;
-    http_version: string;
     risk_rtt?: number;
+    additional_risk_info?: string;
     http_status_code?: number;
-    request_cookie_names?: string[];
-    server_info_region?: string;
-    server_info_datacenter?: string;
-    tls_protocol?: string;
-    tls_cipher?: string;
-    tls_preferred_ciphers?: string;
-    tls_ciphers_sha?: string;
-    tls_ja3_fingerprint?: string;
-    graphql_operations?: GraphQLData[];
     credentials_compromised?: boolean;
-    ci_version?: string;
-    sso_step?: string;
-    cross_tab_session?: string;
-    app_user_id?: string;
-    jwt_additional_fields?: Record<string, any>;
 };
+export type ActivityTypeDetails = PageRequestedActivityDetails | BlockActivityDetails | AdditionalS2SActivityDetails;
 export type PageRequestedActivityDetails = {
     pass_reason: string;
-    px_cookie?: string;
     error_message?: string;
     s2s_error_reason?: string;
     s2s_error_http_status?: number;

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

@@ -0,0 +1,40 @@
+import { HttpMethod } from '../../http';
+import { TokenOrigin } from '../../risk_token';
+import { GraphQLData } from '../../graphql';
+import { ModuleMode, VidSource } from '../../utils';
+import { CredentialIntelligenceVersion, SsoStep } from '../../products';
+import { CustomParameters } from '../../custom_parameters';
+export type CommonActivityDetails = {
+    request_id: string;
+    module_version: string;
+    risk_mode: ModuleMode;
+    http_method: HttpMethod;
+    http_version?: string;
+    px_orig_cookie?: string;
+    px_cookie?: string;
+    px_cookie_hmac?: string;
+    tls_protocol?: string;
+    tls_server?: string;
+    tls_cipher?: string;
+    tls_ciphers_sha?: string;
+    tls_extension_sha?: string;
+    tls_preferred_ciphers?: string;
+    tls_ja3_fingerprint?: string;
+    enforcer_vid_source?: VidSource;
+    original_uuid?: string;
+    original_token_error?: string;
+    original_token?: string;
+    px_decoded_original_token?: string;
+    cookie_origin?: TokenOrigin;
+    request_cookie_names?: string[];
+    server_info_region?: string;
+    server_info_datacenter?: string;
+    cross_tab_session?: string;
+    app_user_id?: string;
+    jwt_additional_fields?: Record<string, any>;
+    graphql_operations?: GraphQLData[];
+    user?: string;
+    pass?: string;
+    ci_version?: CredentialIntelligenceVersion;
+    sso_step?: SsoStep;
+} & CustomParameters;

package/lib/activities/model/CommonActivityDetails.js

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

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

@@ -0,0 +1,4 @@
+export type HeaderEntry = {
+    name: string;
+    value: string;
+};

package/lib/activities/model/HeaderEntry.js

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

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

@@ -1,2 +1,4 @@
-export * from './Activity';
-export * from './ActivityDetails';
+export * from './AsyncActivity';
+export * from './AsyncActivityDetails';
+export * from './HeaderEntry';
+export * from './CommonActivityDetails';

package/lib/activities/model/index.js

@@ -1,2 +1,4 @@
-export * from './Activity';
-export * from './ActivityDetails';
+export * from './AsyncActivity';
+export * from './AsyncActivityDetails';
+export * from './HeaderEntry';
+export * from './CommonActivityDetails';