perimeterx-js-core 0.7.1 → 0.8.0

package/lib/phase/impl/EnrichContextFromRequestPhase.js

@@ -1,60 +1,43 @@
-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 { CustomParametersUtils } from '../../custom_parameters';
 import { DecideActionPhase } from './DecideActionPhase';
 export class EnrichContextFromRequestPhase extends DecideActionPhase {
+    products;
+    dataEnrichment;
+    graphQLParser;
     constructor(config, products, dataEnrichment, graphQLParser) {
         super(config);
         this.products = products;
         this.dataEnrichment = dataEnrichment;
         this.graphQLParser = graphQLParser;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.config.logger.debug('enrich context from request phase');
-            yield this.addPxdeToContext(context);
-            yield this.addGraphQLDataToContext(context);
-            yield this.addProductDataToContext(context);
-            yield this.addCustomParametersToContext(context);
-            yield this.updateContextDecision(context);
-            return { done: false };
-        });
+    async execute(context) {
+        this.config.logger.debug('enrich context from request phase');
+        await this.addPxdeToContext(context);
+        await this.addGraphQLDataToContext(context);
+        await this.addProductDataToContext(context);
+        await this.addCustomParametersToContext(context);
+        await this.updateContextDecision(context);
+        return { done: false };
     }
-    addPxdeToContext(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pxdeData = yield this.dataEnrichment.handlePxde(context);
-            if (pxdeData) {
-                context.pxde = pxdeData.pxde;
-                context.pxdeVerified = pxdeData.pxdeVerified;
-            }
-        });
+    async addPxdeToContext(context) {
+        const pxdeData = await this.dataEnrichment.handlePxde(context);
+        if (pxdeData) {
+            context.pxde = pxdeData.pxde;
+            context.pxdeVerified = pxdeData.pxdeVerified;
+        }
     }
-    addGraphQLDataToContext(context) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((_a = this.graphQLParser) === null || _a === void 0 ? void 0 : _a.isGraphQLRequest(context)) {
-                context.graphqlData = yield this.graphQLParser.parseGraphQLRequest(context);
-            }
-        });
+    async addGraphQLDataToContext(context) {
+        if (this.graphQLParser?.isGraphQLRequest(context)) {
+            context.graphqlData = await this.graphQLParser.parseGraphQLRequest(context);
+        }
     }
-    addProductDataToContext(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(Object.entries(this.products).map(([name, product]) => __awaiter(this, void 0, void 0, function* () {
-                // @ts-ignore
-                context.productData[name] = yield (product === null || product === void 0 ? void 0 : product.enrichContextFromRequest(context));
-            })));
-        });
+    async addProductDataToContext(context) {
+        await Promise.all(Object.entries(this.products).map(async ([name, product]) => {
+            // @ts-ignore
+            context.productData[name] = await product?.enrichContextFromRequest(context);
+        }));
     }
-    addCustomParametersToContext(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            context.customParameters = yield CustomParametersUtils.createCustomParameters(this.config, context);
-        });
+    async addCustomParametersToContext(context) {
+        context.customParameters = await CustomParametersUtils.createCustomParameters(this.config, context);
     }
 }

package/lib/phase/impl/EnrichContextFromResponsePhase.js

@@ -1,31 +1,20 @@
-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 EnrichContextFromResponsePhase {
+    config;
+    products;
     constructor(config, products) {
         this.config = config;
         this.products = products;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.config.logger.debug('enrich context from response phase');
-            yield this.addProductDataToContext(context);
-            return { done: false };
-        });
+    async execute(context) {
+        this.config.logger.debug('enrich context from response phase');
+        await this.addProductDataToContext(context);
+        return { done: false };
     }
-    addProductDataToContext(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(Object.entries(this.products)
-                .filter(([name, _]) => !!context.productData[name])
-                .map(([name, product]) => __awaiter(this, void 0, void 0, function* () {
-                Object.assign(context.productData[name], yield (product === null || product === void 0 ? void 0 : product.enrichContextFromResponse(context)));
-            })));
-        });
+    async addProductDataToContext(context) {
+        await Promise.all(Object.entries(this.products)
+            .filter(([name, _]) => !!context.productData[name])
+            .map(async ([name, product]) => {
+            Object.assign(context.productData[name], await product?.enrichContextFromResponse(context));
+        }));
     }
 }

package/lib/phase/impl/FilterPhase.js

@@ -1,19 +1,9 @@
-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 FilterPhase {
+    filters;
     constructor(filters) {
         this.filters = filters;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return { done: this.filters.some((filter) => filter.shouldFilter(context)) };
-        });
+    async execute(context) {
+        return { done: this.filters.some((filter) => filter.shouldFilter(context)) };
     }
 }

package/lib/phase/impl/FirstPartyPhase.js

@@ -1,42 +1,31 @@
-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';
 export class FirstPartyPhase {
+    httpClient;
+    firstParties;
     constructor(httpClient, firstParties) {
         this.httpClient = httpClient;
         this.firstParties = firstParties;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const firstParty of this.firstParties) {
-                const firstPartyData = yield firstParty.handleFirstPartyRequest(context);
-                if (firstPartyData) {
-                    const response = yield this.sendFirstPartyRequest(firstPartyData);
-                    return { done: true, response };
-                }
+    async execute(context) {
+        for (const firstParty of this.firstParties) {
+            const firstPartyData = await firstParty.handleFirstPartyRequest(context);
+            if (firstPartyData) {
+                const response = await this.sendFirstPartyRequest(firstPartyData);
+                return { done: true, response };
             }
-            return { done: false };
-        });
+        }
+        return { done: false };
     }
-    sendFirstPartyRequest({ request, defaultResponse }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!request) {
-                return defaultResponse;
-            }
-            try {
-                const response = yield this.httpClient.send(request);
-                return MinimalResponseUtils.from(response);
-            }
-            catch (e) {
-                return defaultResponse;
-            }
-        });
+    async sendFirstPartyRequest({ request, defaultResponse }) {
+        if (!request) {
+            return defaultResponse;
+        }
+        try {
+            const response = await this.httpClient.send(request);
+            return MinimalResponseUtils.from(response);
+        }
+        catch (e) {
+            return defaultResponse;
+        }
     }
 }

package/lib/phase/impl/ModifyIncomingRequestPhase.js

@@ -1,20 +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());
-    });
-};
 export class ModifyIncomingRequestPhase {
+    products;
     constructor(products) {
         this.products = products;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(this.products.map((product) => product === null || product === void 0 ? void 0 : product.modifyIncomingRequest(context)));
-            return { done: false };
-        });
+    async execute(context) {
+        await Promise.all(this.products.map((product) => product?.modifyIncomingRequest(context)));
+        return { done: false };
     }
 }

package/lib/phase/impl/ModifyOutgoingResponsePhase.js

@@ -1,25 +1,14 @@
-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 { PXHDSource, PXHDUtils } from '../../pxhd';
 export class ModifyOutgoingResponsePhase {
+    products;
     constructor(products) {
         this.products = products;
     }
-    execute(context) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(this.products.map((product) => product === null || product === void 0 ? void 0 : product.modifyOutgoingResponse(context)));
-            if (((_a = context.pxhd) === null || _a === void 0 ? void 0 : _a.source) === PXHDSource.RISK) {
-                PXHDUtils.addPxhdToOutgoingResponse(context, context.response);
-            }
-            return { done: false };
-        });
+    async execute(context) {
+        await Promise.all(this.products.map((product) => product?.modifyOutgoingResponse(context)));
+        if (context.pxhd?.source === PXHDSource.RISK) {
+            PXHDUtils.addPxhdToOutgoingResponse(context, context.response);
+        }
+        return { done: false };
     }
 }

package/lib/phase/impl/ParseTokenPhase.js

@@ -1,24 +1,14 @@
-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 { TokenParseResult } from '../../risk_token';
 import { transferExistingProperties, VidSource } from '../../utils';
 export class ParseTokenPhase {
+    tokenParser;
     constructor(tokenParser) {
         this.tokenParser = tokenParser;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tokenData = yield this.tokenParser.parseToken(context);
-            this.addTokenDataToContext(context, tokenData);
-            return { done: false };
-        });
+    async execute(context) {
+        const tokenData = await this.tokenParser.parseToken(context);
+        this.addTokenDataToContext(context, tokenData);
+        return { done: false };
     }
     addTokenDataToContext(context, tokenData) {
         Object.assign(context.tokenData, tokenData);

package/lib/phase/impl/PreflightPhase.js

@@ -1,28 +1,20 @@
-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 PreflightPhase {
+    corsSupportEnabled;
+    filterPreflightRequestsEnabled;
+    cors;
     constructor(config, cors) {
         this.corsSupportEnabled = config.corsSupportEnabled;
         this.filterPreflightRequestsEnabled = config.corsPreflightRequestFilterEnabled;
         this.cors = cors;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.corsSupportEnabled || !this.cors.isPreflightRequest(context)) {
-                return { done: false };
-            }
-            const response = yield this.cors.runPreflightCustomHandler(context);
-            if (response) {
-                return { done: true, response };
-            }
-            return { done: this.filterPreflightRequestsEnabled };
-        });
+    async execute(context) {
+        if (!this.corsSupportEnabled || !this.cors.isPreflightRequest(context)) {
+            return { done: false };
+        }
+        const response = await this.cors.runPreflightCustomHandler(context);
+        if (response) {
+            return { done: true, response };
+        }
+        return { done: this.filterPreflightRequestsEnabled };
     }
 }

package/lib/phase/impl/RiskApiPhase.js

@@ -1,46 +1,36 @@
-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 { transferExistingProperties } from '../../utils';
 import { DecideActionPhase } from './DecideActionPhase';
+import { ProductName } from '../../products';
 import { PXHDSource } from '../../pxhd';
 export class RiskApiPhase extends DecideActionPhase {
+    products;
+    riskApiClient;
     constructor(config, products, riskApiClient) {
         super(config);
         this.products = products;
         this.riskApiClient = riskApiClient;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.shouldTriggerRiskApi(context)) {
-                yield this.triggerRiskApi(context);
-                yield this.enrichContextFromRiskApi(context);
-                yield this.updateContextDecision(context);
-            }
-            return { done: false };
-        });
+    async execute(context) {
+        if (this.shouldTriggerRiskApi(context)) {
+            await this.triggerRiskApi(context);
+            await this.enrichContextFromRiskApi(context);
+            await this.updateContextDecision(context);
+        }
+        return { done: false };
     }
     shouldTriggerRiskApi(context) {
         return context.action === Action.TRIGGER_RISK_API;
     }
-    triggerRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const riskApiData = yield this.riskApiClient.executeRiskApi(context);
-            Object.assign(context.riskApiData, riskApiData);
-        });
+    async triggerRiskApi(context) {
+        context.riskApiData.s2sCallReason =
+            context.reasons?.[ProductName.BOT_DEFENDER] || context.reasons?.[ProductName.CREDENTIAL_INTELLIGENCE];
+        const riskApiData = await this.riskApiClient.executeRiskApi(context);
+        Object.assign(context.riskApiData, riskApiData);
     }
-    enrichContextFromRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.addRiskApiDataToContext(context);
-            yield this.enrichContextWithProductDataFromRiskApi(context);
-        });
+    async enrichContextFromRiskApi(context) {
+        this.addRiskApiDataToContext(context);
+        await this.enrichContextWithProductDataFromRiskApi(context);
     }
     addRiskApiDataToContext(context) {
         const { riskResponse } = context.riskApiData;
@@ -64,13 +54,11 @@ export class RiskApiPhase extends DecideActionPhase {
             };
         }
     }
-    enrichContextWithProductDataFromRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(Object.entries(this.products).map(([name, product]) => __awaiter(this, void 0, void 0, function* () {
-                if (context.productData[name]) {
-                    Object.assign(context.productData[name], yield (product === null || product === void 0 ? void 0 : product.enrichContextFromRiskApi(context)));
-                }
-            })));
-        });
+    async enrichContextWithProductDataFromRiskApi(context) {
+        await Promise.all(Object.entries(this.products).map(async ([name, product]) => {
+            if (context.productData[name]) {
+                Object.assign(context.productData[name], await product?.enrichContextFromRiskApi(context));
+            }
+        }));
     }
 }

package/lib/phase/impl/SendAsyncActivitiesOnRequestPhase.js

@@ -1,28 +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());
-    });
-};
 import { Action } from '../../action';
 export class SendAsyncActivitiesOnRequestPhase {
+    activityClient;
     constructor(activityClient) {
         this.activityClient = activityClient;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (context.action === Action.BLOCK) {
-                yield this.sendAsyncActivity(context);
-            }
-            return { done: false };
-        });
+    async execute(context) {
+        if (context.action === Action.BLOCK) {
+            await this.sendAsyncActivity(context);
+        }
+        return { done: false };
     }
-    sendAsyncActivity(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.activityClient.sendActivities(context);
-        });
+    async sendAsyncActivity(context) {
+        await this.activityClient.sendActivities(context);
     }
 }

package/lib/phase/impl/SendAsyncActivitiesOnResponsePhase.js

@@ -1,20 +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());
-    });
-};
 export class SendAsyncActivitiesOnResponsePhase {
+    activityClient;
     constructor(activityClient) {
         this.activityClient = activityClient;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.activityClient.sendActivities(context);
-            return { done: false };
-        });
+    async execute(context) {
+        await this.activityClient.sendActivities(context);
+        return { done: false };
     }
 }

package/lib/phase/impl/SendLogsPhase.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());
-    });
-};
 import { X_PX_ENFORCER_LOG_HEADER } from '../../logger';
 export class SendLogsPhase {
+    config;
+    logServiceClient;
     constructor(config, logServiceClient) {
         this.config = config;
         this.logServiceClient = logServiceClient;
     }
-    execute(context) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const headerValue = (_a = context.requestData.headers[X_PX_ENFORCER_LOG_HEADER]) === null || _a === void 0 ? void 0 : _a[0];
-            if (headerValue == this.config.loggerAuthToken) {
-                yield this.logServiceClient.sendLogs(context, this.config.logger.getLogs());
-            }
-            return { done: false };
-        });
+    async execute(context) {
+        const headerValue = context.requestData.headers[X_PX_ENFORCER_LOG_HEADER]?.[0];
+        if (headerValue == this.config.loggerAuthToken) {
+            await this.logServiceClient.sendLogs(context, this.config.logger.getLogs());
+        }
+        return { done: false };
     }
 }

package/lib/phase/impl/TelemetryPhase.js

@@ -1,29 +1,17 @@
-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 TelemetryPhase {
+    telemetry;
     constructor(telemetry) {
         this.telemetry = telemetry;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (yield this.telemetry.isValidTelemetryRequest(context)) {
-                yield this.sendTelemetry(context);
-                return { done: true };
-            }
-            return { done: false };
-        });
+    async execute(context) {
+        if (await this.telemetry.isValidTelemetryRequest(context)) {
+            await this.sendTelemetry(context);
+            return { done: true };
+        }
+        return { done: false };
     }
     // Note: If await is not necessary, can be overridden
-    sendTelemetry(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.telemetry.sendTelemetry(context);
-        });
+    async sendTelemetry(context) {
+        await this.telemetry.sendTelemetry(context);
     }
 }