@api-client/core 0.9.21 → 0.9.23

package/src/runtime/http-runner/HttpFlowRunner.ts

@@ -1,250 +1,85 @@
-import { CookieJar } from "../../cookies/CookieJar.js";
 import { IHttpRequest } from "../../models/HttpRequest.js";
 import { ISentRequest } from "../../models/SentRequest.js";
 import { IResponse } from "../../models/Response.js";
 import { IErrorResponse } from "../../models/ErrorResponse.js";
-import { HttpCookie } from "../../models/HttpCookie.js";
-import { 
-  FlowSourceEnum, IHttpAction, 
-  IHttpFlow, IHttpCondition,
-} from '../../models/http-actions/HttpFlows.js';
-import { RequestDataExtractor } from "../../data/RequestDataExtractor.js";
-import { checkCondition } from "./ConditionCheck.js";
-import { ApiSchemaValues } from "../../amf/ApiSchemaValues.js";
-import { SameSiteValue } from "../../cookies/CookieParser.js";
-import { IHttpStep } from "../../models/http-actions/HttpStep.js";
-import { IReadDataStep, ReadDataStep, ReadDataStepKind } from "../../models/http-actions/steps/data/ReadDataStep.js";
-import { ISetDataStep, SetDataStep, SetDataStepKind } from "../../models/http-actions/steps/data/SetDataStep.js";
-import { ISetVariableStep, SetVariableStep, SetVariableStepKind } from "../../models/http-actions/steps/data/SetVariableStep.js";
-import { ISetCookieStep, SetCookieStep, SetCookieStepKind } from "../../models/http-actions/steps/data/SetCookieStep.js";
-import { DeleteCookieStep, DeleteCookieStepKind, IDeleteCookieStep } from "../../models/http-actions/steps/data/DeleteCookieStep.js";
+import { IHttpAction, IHttpFlow } from '../../models/http-flows/HttpFlows.js';
+import { IHttpStep } from "../../models/http-flows/HttpStep.js";
+import { HttpFlows, IStepValue } from "./HttpFlows.js";
 
 export type FlowValue = string | number | boolean | null | undefined | unknown;
 
-export class HttpFlowRunner {
+export class HttpFlowRunner extends HttpFlows {
   /**
-   * The cumulative list of all variables to be applied to the request and other properties.
-   * The variables must be already processed for variables in values (evaluated).
-   * 
-   * These variables are passed by reference. Changes made anywhere to the variables will result 
-   * with updating this list.
+   * Runs flows before the HTTP request is sent to the remote machine.
+   * The request has to be pre-processed, that is, variables should already be applied to it.
    */
-  variables?: Record<string, string>;
-
-  /**
-   * An instance of a cookie jar (store) to put/read cookies.
-   */
-  cookies?: CookieJar;
-
   async request(request: IHttpRequest, flows?: IHttpFlow[]): Promise<void> {
     if (!flows || !flows.length) {
       return;
     }
-    for (const flow of flows) {
-      const { condition, actions } = flow;
-      if (condition) {
-        try {
-          const meet = await this._satisfied(condition, request);
-          if (!meet) {
-            continue;
-          }
-        } catch (_) {
-          continue;
-        }
-      }
-      for (const action of actions) {
-        await this._runAction(action, request);
-      }
-    }
+    await this.runFlows(request, flows);
   }
 
   async response(request: IHttpRequest | ISentRequest, response: IResponse | IErrorResponse, flows?: IHttpFlow[]): Promise<void> {
     if (!flows || !flows.length) {
       return;
     }
+    await this.runFlows(request, flows, response);
+  }
+
+  protected async runFlows(request: IHttpRequest | ISentRequest, flows: IHttpFlow[], response?: IResponse | IErrorResponse): Promise<void> {
     for (const flow of flows) {
-      for (const action of flow.actions) {
-        await this._runAction(action, request, response);
+      const { condition, actions } = flow;
+      const passedCondition = await this.checkCondition(request, condition, response);
+      if (!passedCondition) {
+        continue;
+      }
+      for (const action of actions) {
+        try {
+          await this.runAction(action, request, response);
+        } catch (e) {
+          // eslint-disable-next-line no-console
+          console.warn(e);
+          // if the step fails then we stop execution.
+          // TODO: we should generate a report with the list of execution errors and present it in the UI.
+          break;
+        }
       }
     }
   }
 
-  async _runAction(action: IHttpAction, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<void> {
+  async runAction(action: IHttpAction, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<void> {
     const { steps } = action;
     if (!Array.isArray(steps) || !steps.length) {
       return;
     }
-    // this keeps a value from the last step to be passed to the next step.
-    let lastResult: FlowValue;
-    for (const step of steps) {
-      lastResult = await this._runStep(step, lastResult, request, response);
-    }
+    await this.runSteps(steps, request, response);
   }
 
-  async _satisfied(condition: IHttpCondition, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<boolean> {
-    const { source, data, path, operator, value } = condition;
-    if (!source || !operator) {
-      return false;
-    }
-    const extractor = new RequestDataExtractor(request, response);
-    const readValue = await extractor.extract(source, data, path);
-    return checkCondition(readValue, operator, value);
-  }
-
-  async _runStep(step: IHttpStep, input: FlowValue, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<FlowValue> {
-    switch (step.kind) {
-      case ReadDataStepKind: return this._runReadDataStep(step as IReadDataStep, request, response);
-      case SetDataStepKind: return this._runSetDataStep(step as ISetDataStep);
-      case SetVariableStepKind: return this._runSetVariableStep(step as ISetVariableStep, input);
-      case SetCookieStepKind: return this._runSetCookieStep(step as ISetCookieStep, input, request);
-      case DeleteCookieStepKind: return this._runDeleteCookieStep(step as IDeleteCookieStep, request);
-      default: return undefined;
-    }
-  }
-
-  /**
-   * A step that reads data from the request, response, or variables.
-   * 
-   * @param step The step configuration.
-   * @param request The HttpRequest or the SentRequest (for responses)
-   * @param response When available, the response data
-   * @returns The read value or undefined.
-   */
-  async _runReadDataStep(step: IReadDataStep, request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<string | number | undefined> {
-    const instance = new ReadDataStep(step);
-
-    if (instance.enabled === false || !instance.checkValidity()) {
-      return undefined;
-    }
-    const { source, data, path } = step;
-    if (source === FlowSourceEnum.request) {
-      const extractor = new RequestDataExtractor(request);
-      return extractor.extract(source, data, path);
-    }
-
-    if (source === FlowSourceEnum.response) {
-      const extractor = new RequestDataExtractor(request, response);
-      return extractor.extract(source, data, path);
+  async checkCondition(request: IHttpRequest | ISentRequest, condition?: IHttpAction, response?: IResponse | IErrorResponse): Promise<boolean> {
+    if (!condition) {
+      return true;
     }
-
-    if (source === FlowSourceEnum.variable && path && this.variables) {
-      return this.variables[path];
-    }
-
-    return undefined;
-  }
-
-  /**
-   * A step that returns a pre-configured value.
-   * 
-   * @param step The step configuration.
-   * @returns The read value with applied data type.
-   */
-  _runSetDataStep(step: ISetDataStep): FlowValue {
-    const instance = new SetDataStep(step);
-    if (instance.enabled === false || !instance.checkValidity()) {
-      return undefined;
-    }
-    const { value, dataType } = step;
-    if (value === null || value === undefined) {
-      return undefined;
-    }
-    return ApiSchemaValues.parseScalar(value, dataType);
-  }
-
-  /**
-   * A step that sets a variable in the current environment.
-   * 
-   * @param step The step configuration.
-   * @param value The value to set. A value that is `null` or `undefined` deletes the variable.
-   */
-  _runSetVariableStep(step: ISetVariableStep, value: FlowValue): FlowValue {
-    const instance = new SetVariableStep(step);
-    if (instance.enabled === false || !instance.checkValidity() || !this.variables) {
-      return undefined;
-    }
-    const { name } = step;
-    if (value === null || typeof value === undefined) {
-      delete this.variables[name];
-    } else {
-      this.variables[name] = String(value);
-    }
-    return undefined;
-  }
-
-  /**
-   * A step that sets a cookie.
-   * 
-   * @param step The step configuration.
-   * @param value The value to sent on the cookie.
-   * @param request The request object.
-   */
-  async _runSetCookieStep(step: ISetCookieStep, value: FlowValue, request: IHttpRequest | ISentRequest): Promise<FlowValue> {
-    const instance = new SetCookieStep(step);
-    const { cookies } = this;
-    if (instance.enabled === false || !instance.checkValidity() || !cookies ) {
-      return undefined;
-    }
-    if (value === null || typeof value === undefined) {
-      return undefined;
-    }
-    const { name, expires, hostOnly, httpOnly, sameSite, secure, session } = step;
-    const typedValue = String(value);
-    let url: string;
-    if (step.url) {
-      url = step.url;
-    } else {
-      url = request.url;
-    }
-    const cookie = new HttpCookie({
-      name: name,
-      value: typedValue,
-      sameSite: 'unspecified',
-    });
-    
-    if (sameSite) {
-      const typed = sameSite as SameSiteValue;
-      switch (typed.toLowerCase()) {
-        case 'lax': cookie.sameSite = 'lax'; break;
-        case 'strict': cookie.sameSite = 'strict'; break;
-        case 'none': cookie.sameSite = 'no_restriction'; break;
-      }
-    }
-    if (expires) {
-      cookie.expirationDate = expires;
-    }
-    if (typeof hostOnly === 'boolean') {
-      cookie.hostOnly = hostOnly;
-    }
-    if (typeof httpOnly === 'boolean') {
-      cookie.httpOnly = httpOnly;
-    }
-    if (typeof secure === 'boolean') {
-      cookie.secure = secure;
+    const { steps = [] } = condition;
+    if (!Array.isArray(steps) || !steps.length) {
+      return true;
     }
-    if (typeof session === 'boolean') {
-      cookie.session = session;
+    // the condition works with assertions. If the condition throws then it is not satisfied.
+    try {
+      await this.runSteps(steps, request, response);
+      return true;
+    } catch (_) {
+      return false;
     }
-    await cookies.setCookies(url, [cookie]);
-    return undefined;
   }
 
-  /**
-   * A step to delete cookies from the cookie jar.
-   */
-  async _runDeleteCookieStep(step: IDeleteCookieStep, request: IHttpRequest | ISentRequest): Promise<FlowValue> {
-    const instance = new DeleteCookieStep(step);
-    const { cookies } = this;
-    if (instance.enabled === false || !instance.checkValidity() || !cookies) {
-      return undefined;
-    }
-    let url: string;
-    if (step.url) {
-      url = step.url;
-    } else {
-      url = request.url;
+  protected async runSteps(steps: IHttpStep[], request: IHttpRequest | ISentRequest, response?: IResponse | IErrorResponse): Promise<void> {
+    // this keeps a value from the last step to be passed to the next step.
+    let lastResult: IStepValue = {
+      value: undefined,
+    };
+    for (const step of steps) {
+      lastResult = await this.runStep(request, step, lastResult, response);
     }
-    await cookies.deleteCookies(url, step.name);
-    return undefined;
   }
 }