feat: more progress updates

AnWeber · Nov 6, 2021 · dcc5c0a · dcc5c0a
1 parent 2fc8340
commit dcc5c0a
Show file tree

Hide file tree

Showing 16 changed files with 55 additions and 19 deletions.
diff --git a/src/actions/createReqeustBodyInterceptor.ts b/src/actions/createReqeustBodyInterceptor.ts
@@ -13,6 +13,9 @@ export class CreateRequestBodyInterceptor implements models.HookInterceptor<mode
       const contentType = context.arg.request.contentType;
       const requestBodyLines = await this.normalizeBody(this.rawBody, context.arg);
       if (requestBodyLines.length > 0) {
+        context.arg.progress?.report?.({
+          message: 'init request body',
+        });
         if (utils.isMimeTypeFormUrlEncoded(contentType)) {
           context.arg.request.body = this.formUrlEncodedJoin(requestBodyLines);
         } else {

diff --git a/src/actions/createRequestAction.ts b/src/actions/createRequestAction.ts
@@ -6,6 +6,9 @@ export class CreateRequestInterceptor implements models.HookInterceptor<models.P
 
   async beforeTrigger(context: models.HookTriggerContext<models.ProcessorContext, boolean | undefined>): Promise<boolean | undefined> {
     if (context.arg.httpRegion.request && context.index === 0) {
+      context.arg.progress?.report?.({
+        message: 'init request',
+      });
       context.arg.request = cloneDeep(context.arg.httpRegion.request);
     }
     return true;

diff --git a/src/actions/defaultHeadersAction.ts b/src/actions/defaultHeadersAction.ts
@@ -11,6 +11,9 @@ export class DefaultHeadersAction implements HttpRegionAction {
 
   async process(context: ProcessorContext) : Promise<boolean> {
     if (this.data && context.variables) {
+      context.progress?.report?.({
+        message: 'set request headers',
+      });
       const headers = await utils.evalExpression(this.data, context);
       if (headers) {
         this.setHeaders(Object.assign({}, headers), context);

diff --git a/src/actions/envDefaultsHeaderAction.ts b/src/actions/envDefaultsHeaderAction.ts
@@ -1,9 +1,12 @@
 import * as models from '../models';
 
 
-export async function attachDefaultHeaders(request: models.Request, { config }: models.ProcessorContext) : Promise<models.Request> {
-  if (request && config?.defaultHeaders) {
-    const defaultHeaders = config.defaultHeaders;
+export async function attachDefaultHeaders(request: models.Request, context: models.ProcessorContext) : Promise<models.Request> {
+  if (request && context.config?.defaultHeaders) {
+    context.progress?.report?.({
+      message: 'set default request headers',
+    });
+    const defaultHeaders = context.config.defaultHeaders;
     if (!request.headers) {
       request.headers = {
         ...defaultHeaders

diff --git a/src/actions/importMetaAction.ts b/src/actions/importMetaAction.ts
@@ -1,7 +1,7 @@
 import { executeGlobalScripts, toAbsoluteFilename } from '../utils';
 import { ActionType, HttpRegionAction, ProcessorContext, HttpFile } from '../models';
 import { HttpFileStore } from '../store';
-import { fileProvider } from '../io';
+import { fileProvider, log } from '../io';
 
 
 export interface ImportProcessorContext extends ProcessorContext{
@@ -21,6 +21,7 @@ export class ImportMetaAction implements HttpRegionAction {
   async process(context: ImportProcessorContext): Promise<boolean> {
     const absoluteFileName = await toAbsoluteFilename(this.fileName, context.httpFile.fileName);
     if (absoluteFileName) {
+      log.trace(`parse imported file ${absoluteFileName}`);
       const text = await fileProvider.readFile(absoluteFileName, 'utf-8');
       const importHttpFile = await this.httpFileStore.getOrCreate(absoluteFileName, () => Promise.resolve(text), 0, {
         workingDir: context.httpFile.rootDir,
@@ -37,6 +38,7 @@ export class ImportMetaAction implements HttpRegionAction {
         ...context,
         httpFile: importHttpFile,
       };
+      log.trace(`execute global scripts for import ${absoluteFileName}`);
       return await executeGlobalScripts(cloneContext);
     }
     return false;

diff --git a/src/actions/intellijAction.ts b/src/actions/intellijAction.ts
@@ -31,6 +31,7 @@ export class IntellijAction implements models.HttpRegionAction {
     } else {
       data = this.scriptData;
     }
+    log.trace(`execute javascript ${data.script}`);
     context.progress?.report?.({
       message: 'execute javascript',
     });

diff --git a/src/actions/refMetaAction.ts b/src/actions/refMetaAction.ts
@@ -1,6 +1,7 @@
 import * as utils from '../utils';
 import { ActionType, HttpRegionAction } from '../models';
 import { ImportProcessorContext } from './importMetaAction';
+import { log } from '../io';
 export interface RefMetaHttpRegionData {
   name: string;
   force: boolean;
@@ -12,6 +13,7 @@ export class RefMetaAction implements HttpRegionAction {
   constructor(private readonly data: RefMetaHttpRegionData) { }
 
   async process(context: ImportProcessorContext): Promise<boolean> {
+    log.trace(`load reference ${this.data.name}`);
     context.progress?.report?.({
       message: `load reference ${this.data.name}`,
     });
@@ -20,6 +22,7 @@ export class RefMetaAction implements HttpRegionAction {
         && !refHttpRegion.metaData.disabled
         && refHttpRegion !== context.httpRegion) {
         const envkey = utils.toEnvironmentKey(context.httpFile.activeEnvironment);
+        log.trace('import variables', refHttpRegion.variablesPerEnv[envkey]);
         Object.assign(context.variables, refHttpRegion.variablesPerEnv[envkey]);
         if (this.data.force || !context.variables[this.data.name]) {
           const refContext = { ...context, httpRegion: refHttpRegion };

diff --git a/src/actions/requestVariableReplacer.ts b/src/actions/requestVariableReplacer.ts
@@ -3,6 +3,9 @@ import * as utils from '../utils';
 
 
 export async function requestVariableReplacer(request: models.Request, context: models.ProcessorContext): Promise<models.Request | typeof models.HookCancel> {
+  context.progress?.report?.({
+    message: 'replace variables in request',
+  });
   if (request.url) {
     const result = await utils.replaceVariables(request.url, models.VariableType.url, context) || request.url;
     if (result === models.HookCancel) {

diff --git a/src/io/gotHttpClientFactory.ts b/src/io/gotHttpClientFactory.ts
@@ -90,7 +90,7 @@ async function load(url: string, options: OptionsOfUnknownResponseBody, context:
       prevPercent = data.percent;
       if (context.progress?.report) {
         context.progress.report({
-          message: url,
+          message: 'call http request',
           increment: newData * 100,
         });
       }

diff --git a/src/models/hook.ts b/src/models/hook.ts
@@ -147,8 +147,6 @@ export abstract class Hook<T, TReturn, TTriggerResult, TArg = undefined, TArg2 =
       } catch (err) {
         log.error(`${this.id}: ${context.hookItem.id} failed`);
         throw err;
-      } finally {
-        log.trace(`${this.id}: ${context.hookItem.id} finished`);
       }
     }
     if ((await this.intercept(obj => obj.afterLoop, context)) === false) {

diff --git a/src/parser/javascriptHttpRegionParser.ts b/src/parser/javascriptHttpRegionParser.ts
@@ -39,17 +39,17 @@ export async function parseJavascript(
             switch (match.groups.event) {
               case 'request':
                 httpRegion.hooks.onRequest.addHook(models.ActionType.js, async (_request, context) => {
-                  await executeScriptData(scriptData, context);
+                  await executeScriptData(scriptData, context, 'request');
                 });
                 break;
               case 'streaming':
                 httpRegion.hooks.onStreaming.addHook(models.ActionType.js, async context => {
-                  await executeScriptData(scriptData, context);
+                  await executeScriptData(scriptData, context, 'streaming');
                 });
                 break;
               case 'response':
                 httpRegion.hooks.onResponse.addHook(models.ActionType.js, async (_response, context) => {
-                  await executeScriptData(scriptData, context);
+                  await executeScriptData(scriptData, context, 'response');
                 });
                 break;
               case 'after':
@@ -100,20 +100,23 @@ export async function injectOnEveryRequestJavascript({ data, httpRegion }: model
       switch (everyRequestScript.event) {
         case 'streaming':
           httpRegion.hooks.onStreaming.addHook(models.ActionType.js, async context => {
-            await executeScriptData(scriptData, context);
+            await executeScriptData(scriptData, context, 'streaming');
           });
           break;
         case 'response':
+
           httpRegion.hooks.onResponse.addHook(models.ActionType.js, async (_response, context) => {
-            await executeScriptData(scriptData, context);
+            await executeScriptData(scriptData, context, 'response');
           });
           break;
         case 'after':
-          httpRegion.hooks.execute.addHook(models.ActionType.js, context => executeScriptData(scriptData, context));
+          httpRegion.hooks.execute.addHook(models.ActionType.js, async context => {
+            await executeScriptData(scriptData, context, 'after');
+          });
           break;
         case 'request':
           httpRegion.hooks.onRequest.addHook(models.ActionType.js, async (_request, context) => {
-            await executeScriptData(scriptData, context);
+            await executeScriptData(scriptData, context, 'request');
           });
           break;
         default:
@@ -127,18 +130,18 @@ export async function injectOnEveryRequestJavascript({ data, httpRegion }: model
 export class BeforeJavascriptHookInterceptor implements models.HookInterceptor<models.ProcessorContext, boolean> {
   constructor(private readonly scriptData: ScriptData) { }
   async beforeTrigger(context: models.HookTriggerContext<models.ProcessorContext, boolean | undefined>): Promise<boolean | undefined> {
-    return await executeScriptData(this.scriptData, context.arg);
+    return await executeScriptData(this.scriptData, context.arg, 'before');
   }
 }
 export class AfterJavascriptHookInterceptor implements models.HookInterceptor<models.ProcessorContext, boolean> {
   constructor(private readonly scriptData: ScriptData) { }
   async afterTrigger(context: models.HookTriggerContext<models.ProcessorContext, boolean | undefined>): Promise<boolean | undefined> {
-    return await executeScriptData(this.scriptData, context.arg);
+    return await executeScriptData(this.scriptData, context.arg, 'after');
   }
 }
-async function executeScriptData(scriptData: ScriptData, context: models.ProcessorContext) {
+async function executeScriptData(scriptData: ScriptData, context: models.ProcessorContext, eventName?: string) {
   context.progress?.report?.({
-    message: 'execute javascript',
+    message: eventName ? `execute javascript (@${eventName})` : 'execute javascript',
   });
   const result = await utils.runScript(scriptData.script, {
     fileName: context.httpFile.fileName,

diff --git a/src/variables/replacer/oauth/authorizationCodeFlow.ts b/src/variables/replacer/oauth/authorizationCodeFlow.ts
@@ -23,6 +23,9 @@ class AuthorizationCodeFlow implements OpenIdFlow {
       return new Promise<OpenIdInformation | false>((resolve, reject) => {
         const state = stateGenerator();
         try {
+          context.progress?.report?.({
+            message: 'execute OAuth2 authorization_code flow',
+          });
           const redirectUri = 'http://localhost:3000/callback';
           const authUrl = `${config.authorizationEndpoint}${config.authorizationEndpoint.indexOf('?') > 0 ? '&' : '?'}${toQueryParams({
             client_id: config.clientId,

diff --git a/src/variables/replacer/oauth/clientCredentialsFlow.ts b/src/variables/replacer/oauth/clientCredentialsFlow.ts
@@ -19,6 +19,9 @@ class ClientCredentialsFlow implements OpenIdFlow {
   async perform(config: OpenIdConfiguration, context: OpenIdFlowContext): Promise<OpenIdInformation | false> {
     const id = this.getCacheKey(config);
     if (id) {
+      context.progress?.report?.({
+        message: 'execute OAuth2 client_credentials flow',
+      });
       return requestOpenIdInformation({
         url: config.tokenEndpoint,
         method: 'POST',

diff --git a/src/variables/replacer/oauth/passwordFlow.ts b/src/variables/replacer/oauth/passwordFlow.ts
@@ -18,6 +18,9 @@ class PasswordFlow implements OpenIdFlow {
   async perform(config: OpenIdConfiguration, context: OpenIdFlowContext): Promise<OpenIdInformation | false> {
     const id = this.getCacheKey(config);
     if (id) {
+      context.progress?.report?.({
+        message: 'execute OAuth2 password flow',
+      });
       return requestOpenIdInformation({
         url: config.tokenEndpoint,
         method: 'POST',

diff --git a/src/variables/replacer/oauth/refreshTokenFlow.ts b/src/variables/replacer/oauth/refreshTokenFlow.ts
@@ -15,7 +15,9 @@ class RefreshTokenFlow {
     if (openIdInformation.refreshToken
       && openIdInformation.refreshExpiresIn
       && !this.isTokenExpired(openIdInformation.time, openIdInformation.refreshExpiresIn, openIdInformation.timeSkew)) {
-
+      context.progress?.report?.({
+        message: 'execute OAuth2 refresh_token flow',
+      });
       return requestOpenIdInformation({
         url: openIdInformation.config.tokenEndpoint,
         method: 'POST',

diff --git a/src/variables/replacer/oauth/tokenExchangeFlow.ts b/src/variables/replacer/oauth/tokenExchangeFlow.ts
@@ -16,6 +16,9 @@ export class TokenExchangeFlow {
     openIdInformation: OpenIdInformation,
     context: ProcessorContext): Promise<OpenIdInformation | false> {
     if (openIdInformation) {
+      context.progress?.report?.({
+        message: 'execute OAuth2 token exchange flow',
+      });
       const jwtToken = decodeJWT(openIdInformation.accessToken);
 
       return requestOpenIdInformation({