perimeterx-js-core 0.7.0 → 0.8.0

package/lib/logger/constants.js

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

package/lib/logger/index.d.ts

@@ -1,4 +1,8 @@
 export { ILogger } from './ILogger';
+export { ILogServiceClient } from './ILogServiceClient';
 export { LoggerBase } from './LoggerBase';
+export { HttpLogServiceClient } from './HttpLogServiceClient';
 export { DefaultLogger } from './DefaultLogger';
 export { LoggerSeverity } from './LoggerSeverity';
+export * from './constants';
+export * from './model';

package/lib/logger/index.js

@@ -1,3 +1,6 @@
 export { LoggerBase } from './LoggerBase';
+export { HttpLogServiceClient } from './HttpLogServiceClient';
 export { DefaultLogger } from './DefaultLogger';
 export { LoggerSeverity } from './LoggerSeverity';
+export * from './constants';
+export * from './model';

package/lib/logger/model/EnrichedLogRecord.d.ts

@@ -0,0 +1,3 @@
+import { LogMetadata } from './LogMetadata';
+import { LogRecord } from './LogRecord';
+export type EnrichedLogRecord = LogMetadata & LogRecord;

package/lib/logger/model/EnrichedLogRecord.js

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

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

@@ -0,0 +1,9 @@
+export type LogMetadata = {
+    container: string;
+    appID: string;
+    method: string;
+    host: string;
+    url: string;
+    path: string;
+    requestId: string;
+};

package/lib/logger/model/LogMetadata.js

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

package/lib/logger/model/LogRecord.d.ts

@@ -0,0 +1,6 @@
+import { LoggerSeverity } from '../LoggerSeverity';
+export type LogRecord = {
+    message: string;
+    severity: LoggerSeverity;
+    messageTimestamp: number;
+};

package/lib/logger/model/LogRecord.js

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

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

@@ -0,0 +1,3 @@
+export * from './LogMetadata';
+export * from './LogRecord';
+export * from './EnrichedLogRecord';

package/lib/logger/model/index.js

@@ -0,0 +1,3 @@
+export * from './LogMetadata';
+export * from './LogRecord';
+export * from './EnrichedLogRecord';

package/lib/phase/flow/EndEnforcerFlow.d.ts

@@ -0,0 +1,6 @@
+import { IConfiguration } from '../../config';
+import { CompositePhase } from '../impl';
+import { EnforcerBaseOptions } from '../../enforcer';
+export declare class EndEnforcerFlow<Req, Res> extends CompositePhase<Req, Res> {
+    constructor(config: IConfiguration<Req, Res>, { logServiceClient }: Required<EnforcerBaseOptions<Req, Res>>);
+}

package/lib/phase/flow/EndEnforcerFlow.js

@@ -0,0 +1,10 @@
+import { CompositePhase, SendLogsPhase } from '../impl';
+export class EndEnforcerFlow extends CompositePhase {
+    constructor(config, { logServiceClient }) {
+        const phasesArray = [];
+        if (logServiceClient) {
+            phasesArray.push(new SendLogsPhase(config, logServiceClient));
+        }
+        super(phasesArray);
+    }
+}

package/lib/phase/flow/index.d.ts

@@ -1,3 +1,4 @@
 export * from './FilterFlow';
 export * from './EnforceFlow';
 export * from './PostEnforceFlow';
+export * from './EndEnforcerFlow';

package/lib/phase/flow/index.js

@@ -1,3 +1,4 @@
 export * from './FilterFlow';
 export * from './EnforceFlow';
 export * from './PostEnforceFlow';
+export * from './EndEnforcerFlow';

package/lib/phase/impl/AdditionalActivityHandlerPhase.js

@@ -1,22 +1,11 @@
-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 { AdditionalActivityHandlerUtils } from '../../additional_activity_handler';
 export class AdditionalActivityHandlerPhase {
+    config;
     constructor(config) {
         this.config = config;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.config.logger.debug('calling additional activity handler');
-            yield AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler(this.config, context);
-            return { done: false };
-        });
+    async execute(context) {
+        await AdditionalActivityHandlerUtils.invokeAdditionalActivityHandler(this.config, context);
+        return { done: false };
     }
 }

package/lib/phase/impl/CompositePhase.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());
-    });
-};
 export class CompositePhase {
+    phases;
     constructor(phases) {
         this.phases = phases;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let result;
-            for (const phase of this.phases) {
-                result = yield phase.execute(context);
-                if (result.done) {
-                    break;
-                }
+    async execute(context) {
+        let result;
+        for (const phase of this.phases) {
+            result = await phase.execute(context);
+            if (result.done) {
+                break;
             }
-            return result;
-        });
+        }
+        return result;
     }
 }

package/lib/phase/impl/CreateBlockResponsePhase.js

@@ -1,42 +1,34 @@
-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';
 import { PXHDSource, PXHDUtils } from '../../pxhd';
 import { Action } from '../../action';
 import { PRODUCT_PRIORITY_ORDER } from '../../products';
 export class CreateBlockResponsePhase {
+    config;
+    blockers;
+    cors;
     constructor(config, blockers, cors) {
         this.config = config;
         this.blockers = blockers;
         this.cors = cors;
     }
-    execute(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (context.action !== Action.BLOCK) {
-                return { done: false };
-            }
-            this.config.logger.debug('create block response phase');
-            let response = this.createBlockResponse(context);
-            if (!response) {
-                return { done: false };
-            }
-            response = yield this.addHeadersToResponse(response, context);
-            return { done: true, response };
-        });
+    async execute(context) {
+        if (context.action !== Action.BLOCK) {
+            return { done: false };
+        }
+        this.config.logger.debug('create block response phase');
+        let response = this.createBlockResponse(context);
+        if (!response) {
+            return { done: false };
+        }
+        response = await this.addHeadersToResponse(response, context);
+        return { done: true, response };
     }
     createBlockResponse(context) {
         let response = null;
         for (const name of PRODUCT_PRIORITY_ORDER) {
             if (context.reasons[name]) {
                 const blocker = this.blockers[name];
-                if (blocker === null || blocker === void 0 ? void 0 : blocker.shouldBlock(context)) {
+                if (blocker?.shouldBlock(context)) {
                     this.config.logger.debug(`returning ${name} block response`);
                     response = blocker.createBlockResponse(context);
                     break;
@@ -45,17 +37,14 @@ export class CreateBlockResponsePhase {
         }
         return response;
     }
-    addHeadersToResponse(response, context) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!context.isMobile && ((_a = context.pxhd) === null || _a === void 0 ? void 0 : _a.source) === PXHDSource.RISK) {
-                response = PXHDUtils.addPxhdToMinimalResponse(context, response);
-            }
-            if (this.config.corsSupportEnabled && ((_b = this.cors) === null || _b === void 0 ? void 0 : _b.isCorsRequest(context))) {
-                const corsHeaders = yield this.cors.getCorsBlockHeaders(context);
-                response = MinimalResponseUtils.appendHeaders(response, corsHeaders);
-            }
-            return response;
-        });
+    async addHeadersToResponse(response, context) {
+        if (!context.isMobile && context.pxhd?.source === PXHDSource.RISK) {
+            response = PXHDUtils.addPxhdToMinimalResponse(context, response);
+        }
+        if (this.config.corsSupportEnabled && this.cors?.isCorsRequest(context)) {
+            const corsHeaders = await this.cors.getCorsBlockHeaders(context);
+            response = MinimalResponseUtils.appendHeaders(response, corsHeaders);
+        }
+        return response;
     }
 }

package/lib/phase/impl/DecideActionPhase.js

@@ -1,29 +1,19 @@
-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 { LoggerSeverity } from '../../logger';
 import { getDecisionFromContext } from '../../action';
 export class DecideActionPhase {
+    config;
     constructor(config) {
         this.config = config;
     }
-    updateContextDecision(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { action, reasons } = getDecisionFromContext(context);
-            if (this.config.logger.getLoggerSeverity() === LoggerSeverity.DEBUG) {
-                const productReasons = Object.entries(reasons)
-                    .map(([prod, reason]) => `${prod} -> ${reason}`)
-                    .join(', ');
-                this.config.logger.debug(`decision: ${action}, reasons: ${productReasons}`);
-            }
-            context.action = action;
-            context.reasons = reasons;
-        });
+    async updateContextDecision(context) {
+        const { action, reasons } = getDecisionFromContext(context);
+        if (this.config.logger.getLoggerSeverity() === LoggerSeverity.DEBUG) {
+            const productReasons = Object.entries(reasons)
+                .map(([prod, reason]) => `${prod} -> ${reason}`)
+                .join(', ');
+            this.config.logger.debug(`decision: ${action}, reasons: ${productReasons}`);
+        }
+        context.action = action;
+        context.reasons = reasons;
     }
 }

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