@api-client/core 0.9.21 → 0.9.23

package/src/data/DataExtractor.ts

@@ -0,0 +1,188 @@
+import { IHttpRequest, HttpRequest } from '../models/HttpRequest.js';
+import { ISentRequest, SentRequest } from '../models/SentRequest.js';
+import { IHttpResponse, HttpResponse } from '../models/HttpResponse.js';
+import { IErrorResponse, ErrorResponse } from '../models/ErrorResponse.js';
+import { Headers } from '../lib/headers/Headers.js';
+import { DataReader } from './DataReader.js';
+import { JmespathReader } from './JmespathReader.js';
+import { XmlReader } from './XmlReader.js';
+import { UrlEncodedReader } from './UrlEncodedReader.js';
+import { CookieParser } from '../cookies/CookieParser.js';
+
+type DataInput = HttpRequest | SentRequest | IHttpRequest | ISentRequest | IHttpResponse | HttpResponse | IErrorResponse | ErrorResponse | undefined;
+
+/**
+ * This is a factory class for the `RequestDataExtractor`.
+ */
+export class DataExtractor {
+  /**
+   * Reads the value of a cookie.
+   * @param name The name of the cookie to read.
+   * @param input The response object.
+   */
+  static readCookieValue(name: string, input: IHttpResponse | HttpResponse | IErrorResponse | ErrorResponse | undefined): string | undefined {
+    const headers = this.readHeaders(input);
+    if (!headers) {
+      return undefined;
+    }
+    const parsed = new Headers(headers);
+    const header = parsed.get('set-cookie');
+    if (!header) {
+      return undefined;
+    }
+    const cookies = CookieParser.parseRelaxed(header);
+    const cookie = cookies.find(i => i.name === name);
+    if (cookie) {
+      return cookie.value;
+    }
+    return undefined;
+  }
+
+  static readHeaders(obj: DataInput): string {
+    if (!obj) {
+      return '';
+    }
+    const typedInstance = obj as HttpRequest | SentRequest;
+    if (typedInstance.headersModel && typeof typedInstance.headersModel.toRawString === 'function') {
+      return typedInstance.headersModel.toString();
+    }
+    const typedSchema = obj as IHttpRequest | ISentRequest;
+    if (Array.isArray(typedSchema.headersModel)) {
+      const headers = Headers.fromPropertyArray(typedSchema.headersModel);
+      return headers.toString();
+    }
+    return obj.headers || '';
+  }
+
+  /**
+   * Reads value from the body.
+   * @param value The read body value as string
+   * @param mime The body mime
+   * @param path THe path to read.
+   * @returns The extracted value.
+   */
+  static async extractBody(value: string, mime: string, path: string): Promise<string | undefined> {
+    let reader: DataReader | undefined;
+    if (mime.includes('json')) {
+      // reader = new JsonReader();
+      reader = new JmespathReader();
+    } else if (mime.includes('xml')) {
+      reader = new XmlReader();
+    } else if (mime.includes('x-www-form-urlencoded')) {
+      reader = new UrlEncodedReader();
+    }
+    if (!reader) {
+      return undefined;
+    }
+    await reader.writePayload(value);
+    return reader.getValue(path) as Promise<string>;
+  }
+
+  /**
+   * Returns the value for path for given source object
+   *
+   * @param url An url to parse.
+   * @param path Path to the data
+   * @return Value for the path.
+   */
+  static getDataUrl(url: string, path: string[]): string | number | undefined {
+    if (!path || path.length === 0 || !url) {
+      return url;
+    }
+    let value: URL | undefined;
+    try {
+      value = new URL(url);
+    } catch (e) {
+      // 
+    }
+    if (!value) {
+      return undefined;
+    }
+    switch (path[0]) {
+      case 'host':
+        return value.host;
+      case 'protocol':
+        return value.protocol;
+      case 'path':
+        return value.pathname;
+      case 'query':
+        return DataExtractor.readUrlQueryValue(value, path[1]) || undefined;
+      case 'hash':
+        return DataExtractor.readUrlHashValue(value, path[1]) || undefined;
+      default:
+        throw new Error(`Unknown path in the URL: ${path}`);
+    }
+  }
+
+  /**
+   * Reads value of the URL query parameters.
+   *
+   * The `?` at the beginning of the query string is removed.
+   *
+   * @param url The URL object instance
+   * @param param Param name to return. If not set then it returns  whole query string value.
+   * @return Full query string value if `param` is not set or parameter
+   * value. This function does not returns `null` values.
+   */
+  static readUrlQueryValue(url: URL, param?: string): string | null {
+    if (!param) {
+      let v = url.search || '';
+      if (v[0] === '?') {
+        v = v.substring(1);
+      }
+      return v;
+    }
+    let value = url.searchParams.get(param);
+    if (!value && value !== '') {
+      value = null;
+    }
+    return value;
+  }
+
+  /**
+   * Reads value of the URL hash.
+   *
+   * The `#` at the beginning of the hash string is removed.
+   *
+   * If the `param` argument is set then it treats hahs value as a query
+   * parameters string and parses it to get the value.
+   *
+   * @param url The URL object instance
+   * @param param Param name to return. If not set then it returns whole hash string value.
+   * @return Hash parameter or whole hash value.
+   */
+  static readUrlHashValue(url: URL, param?: string): string | undefined {
+    let value: string | undefined = (url.hash || '').substring(1);
+    if (!param) {
+      return value;
+    }
+    const obj = new URLSearchParams(value);
+    value = obj.get(param) || undefined;
+    if (!value && value !== '') {
+      value = undefined;
+    }
+    return value;
+  }
+
+
+  /**
+   * Returns a value for the headers.
+   *
+   * @param source HTTP headers string
+   * @param path The path to the object
+   * @returns The value for the path.
+   */
+  static getDataHeaders(source: string, path: string[]): string | undefined {
+    if (!path || !path.length || !path[0]) {
+      return source;
+    }
+    const headers = new Headers(source);
+    const lowerName = path[0].toLowerCase();
+    for (const [name, value] of headers) {
+      if (name.toLowerCase() === lowerName) {
+        return value;
+      }
+    }
+    return undefined;
+  }
+}

package/src/data/RequestDataExtractor.ts

@@ -1,14 +1,10 @@
-import * as DataUtils from './DataUtils.js';
 import { IHttpRequest, HttpRequest } from '../models/HttpRequest.js';
 import { ISentRequest, SentRequest } from '../models/SentRequest.js';
 import { IHttpResponse, HttpResponse } from '../models/HttpResponse.js';
 import { IErrorResponse, ErrorResponse } from '../models/ErrorResponse.js';
-import { FlowRequestDataEnum, FlowResponseDataEnum, FlowSourceEnum } from '../models/http-actions/HttpFlows.js';
+import { FlowRequestDataEnum, FlowResponseDataEnum, FlowSourceEnum } from '../models/http-flows/HttpFlows.js';
 import { Headers } from '../lib/headers/Headers.js';
-import { JsonReader } from './JsonReader.js';
-import { XmlReader } from './XmlReader.js';
-import { UrlEncodedReader } from './UrlEncodedReader.js';
-import { DataReader } from './DataReader.js';
+import { DataExtractor } from './DataExtractor.js';
 
 /**
  * A class to extract data from the request or the response.
@@ -47,15 +43,19 @@ export class RequestDataExtractor {
     const args = path ? path.split('.') : [];
     switch (data) {
       case 'url':
-        return DataUtils.getDataUrl(this.getUrl(), args);
+        return DataExtractor.getDataUrl(this.getUrl(), args);
       case 'headers':
-        return DataUtils.getDataHeaders(this.getHeaders(source), args);
+        return DataExtractor.getDataHeaders(this.getHeaders(source), args);
       case 'status':
         return this.response && this.response.status;
+      case 'statusText':
+        return this.response && this.response.statusText;
       case 'method':
         return this.request.method;
       case 'body':
         return this.processBody(path, source);
+      case 'cookie':
+        return DataExtractor.readCookieValue(args[0], this.response);
       default:
         throw new Error(`Unknown data ${data} for ${source} data`);
     }
@@ -74,10 +74,7 @@ export class RequestDataExtractor {
    * @returns The headers from the request / response
    */
   getHeaders(source?: FlowSourceEnum): string {
-    if (source === 'request') {
-      return this.request.headers || '';
-    }
-    return this.response && this.response.headers || '';
+    return DataExtractor.readHeaders(source === 'request' ? this.request : this.response);
   }
 
   async processBody(path?: string, source?: FlowSourceEnum): Promise<string | undefined> {
@@ -97,7 +94,7 @@ export class RequestDataExtractor {
     if (!mime) {
       return undefined;
     }
-    return this.extractBody(value, mime, path);
+    return DataExtractor.extractBody(value, mime, path);
   }
 
   /**
@@ -114,19 +111,10 @@ export class RequestDataExtractor {
     return undefined;
   }
 
+  /**
+   * @deprecated Use `DataExtractor.extractBody()` instead.
+   */
   async extractBody(value: string, mime: string, path: string): Promise<string | undefined> {
-    let reader: DataReader | undefined;
-    if (mime.includes('json')) {
-      reader = new JsonReader();
-    } else if (mime.includes('xml')) {
-      reader = new XmlReader();
-    } else if (mime.includes('x-www-form-urlencoded')) {
-      reader = new UrlEncodedReader();
-    }
-    if (!reader) {
-      return undefined;
-    }
-    await reader.writePayload(value);
-    return reader.getValue(path) as Promise<string>;
+    return DataExtractor.extractBody(value, mime, path)
   }
 }

package/src/models/Request.ts

@@ -13,9 +13,9 @@ import { ARCSavedRequest, ARCHistoryRequest } from './legacy/request/ArcRequest.
 import { ErrorResponse as LegacyErrorResponse, Response as LegacyResponse } from './legacy/request/ArcResponse.js';
 import { PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
 import { Normalizer } from './legacy/Normalizer.js';
-import { IHttpFlow } from './http-actions/HttpFlows.js';
-import { IHttpAssertion } from './http-actions/HttpAssertion.js';
-import { LegacyTranslator } from './http-actions/LegacyTranslator.js';
+import { IHttpFlow } from './http-flows/HttpFlows.js';
+import { IHttpAssertion } from './http-flows/HttpAssertion.js';
+import { LegacyTranslator } from './http-flows/LegacyTranslator.js';
 
 export const Kind = 'Core#Request';
 export const createdSymbol = Symbol('created');

package/src/models/RequestLog.ts

@@ -4,7 +4,7 @@ import { IErrorResponse, ErrorResponse } from './ErrorResponse.js';
 import { IResponse, Response } from './Response.js';
 import { IRequestsSize, RequestsSize } from './RequestsSize.js';
 import { ResponseRedirect as LegacyRedirect } from './legacy/request/ArcResponse.js';
-import { AssertionResult } from './http-actions/HttpAssertion.js';
+import { AssertionResult } from './http-flows/HttpAssertion.js';
 
 export const Kind = 'Core#ResponseLog';
 

package/src/models/{http-actions → http-flows}/HttpFlows.ts

@@ -1,4 +1,3 @@
-import { AssertionEnum } from './HttpAssertion.js';
 import { IHttpStep } from './HttpStep.js';
 
 export enum FlowSourceEnum {
@@ -28,6 +27,10 @@ export enum FlowResponseDataEnum {
   status = "status",
   statusText = "statusText",
   headers = "headers",
+  /**
+   * Reads the value of a cookie in the `set-cookie` header.
+   */
+  cookie = "cookie",
   body = "body"
 }
 
@@ -54,7 +57,7 @@ export interface IHttpFlow {
   /**
    * A condition to check before running the flow.
    */
-  condition?: IHttpCondition;
+  condition?: IHttpAction;
 }
 
 /**
@@ -76,40 +79,3 @@ export interface IHttpAction {
    */
   steps: IHttpStep[];
 }
-
-/**
- * A condition to execute for an action.
- */
-export interface IHttpCondition {
-  /**
-   * The main data source.
-   * In the legacy actions this was `type`.
-   */
-  source?: FlowSourceEnum;
-  /**
-   * Source of the data.
-   * In the legacy actions this was `source`.
-   * This is not required when the source is not `request` or `response`.
-   */
-  data?: FlowRequestDataEnum | FlowResponseDataEnum;
-  /**
-   * The path to the data.
-   * For JSON value use https://jmespath.org/ syntax.
-   * For XML use xpath.
-   * For any other use a simple path to the data separated by dot (e.g. headers.content-type)
-   */
-  path?: string;
-  /**
-   * The comparison operator.
-   */
-  operator?: AssertionEnum;
-  /**
-   * The value to compare the read result.
-   * In runtime, the type is casted to the same type as read value.
-   * 
-   * When this is not set it compares to an empty string value or `0`.
-   * 
-   * In ARC actions this was the `predictedValue`.
-   */
-  value?: string;
-}

package/src/models/{http-actions → http-flows}/LegacyTranslator.ts

@@ -4,16 +4,21 @@ import {
   SetCookieConfig, SetVariableConfig, DeleteCookieConfig, DataSourceConfiguration 
 } from '../../models/legacy/actions/Actions.js';
 import { 
-  IHttpFlow, IHttpAction, IHttpCondition, FlowSourceEnum, FlowRequestDataEnum, 
+  IHttpFlow, IHttpAction, FlowSourceEnum, FlowRequestDataEnum, 
   FlowResponseDataEnum,
 } from './HttpFlows.js';
 import { AmfNamespace } from '../../amf/definitions/Namespace.js';
-import { AssertionEnum } from './HttpAssertion.js';
 import { IHttpStep } from './HttpStep.js';
-import { IReadDataStep, ReadDataStepKind } from './steps/data/ReadDataStep.js';
+import { IReadDataStep, ReadDataStep, ReadDataStepKind } from './steps/data/ReadDataStep.js';
 import { ISetDataStep, SetDataStepKind } from './steps/data/SetDataStep.js';
 import { ISetCookieStep, SetCookieStepKind } from './steps/data/SetCookieStep.js';
 import { DeleteCookieStepKind, IDeleteCookieStep } from './steps/data/DeleteCookieStep.js';
+import { IncludesAssertion } from './steps/assertion/IncludesAssertion.js';
+import { EqualAssertion } from './steps/assertion/EqualAssertion.js';
+import { GreaterThanAssertion } from './steps/assertion/GreaterThanAssertion.js';
+import { LessThanAssertion } from './steps/assertion/LessThanAssertion.js';
+import { NotEqualAssertion } from './steps/assertion/NotEqualAssertion.js';
+import { MatchesAssertion } from './steps/assertion/MatchesAssertion.js';
 
 /**
  * Allows to translate the old ARC actions into Action flows.
@@ -64,45 +69,98 @@ export class LegacyTranslator {
     return flow;
   }
 
-  protected static _translateCondition(runnable: LegacyCondition): IHttpCondition | undefined {
+  protected static _translateCondition(runnable: LegacyCondition): IHttpAction | undefined {
     const { source, alwaysPass, operator, path, predictedValue, type } = runnable;
     if (alwaysPass) {
       // in the flow, if there's no condition the steps are always executed.
       return undefined
     }
-
-    const result: IHttpCondition = {};
-    if (typeof path === 'string') {
-      result.path = path;
+    if (!path || !type) {
+      return undefined;
     }
-    if (type) {
-      switch (type) {
-        case 'request': result.source = FlowSourceEnum.request; break;
-        case 'response': result.source = FlowSourceEnum.response; break;
-      }
+    if (!['request', 'response'].includes(type)) {
+      return;
     }
-    if (type && source) {
+
+    const result: IHttpAction = {
+      steps: [],
+    };
+    const readData = new ReadDataStep();
+    readData.source = type === 'request' ? FlowSourceEnum.request : FlowSourceEnum.response;
+    readData.path = path;
+    if (source) {
       if (type === 'request') {
-        result.data = source as FlowRequestDataEnum;
-      }
-      if (type === 'response') {
-        result.data = source as FlowResponseDataEnum;
+        readData.data = source as FlowRequestDataEnum;
+      } else if (type === 'response') {
+        readData.data = source as FlowResponseDataEnum;
       }
     }
-    if (predictedValue) {
-      result.value = String(predictedValue);
-    }
-    if (operator) {
-      switch (operator) {
-        case 'contains': result.operator = AssertionEnum.contains; break;
-        case 'equal': result.operator = AssertionEnum.equal; break;
-        case 'greater-than': result.operator = AssertionEnum.greaterThan; break;
-        case 'greater-than-equal': result.operator = AssertionEnum.greaterThanEqual; break;
-        case 'less-than': result.operator = AssertionEnum.lessThan; break;
-        case 'less-than-equal': result.operator = AssertionEnum.lessThanEqual; break;
-        case 'not-equal': result.operator = AssertionEnum.notEqual; break;
-        case 'regex': result.operator = AssertionEnum.regex; break;
+    result.steps.push(readData.toJSON());
+    if (!operator) {
+      return result;
+    }
+    if (operator === 'contains') {
+      const assertion = new IncludesAssertion();
+      if (predictedValue) {
+        assertion.value = String(predictedValue);
+      }
+      result.steps.push(assertion.toJSON());
+    } else if (operator === 'equal') {
+      const assertion = new EqualAssertion();
+      if (predictedValue) {
+        assertion.value = String(predictedValue);
+      }
+      result.steps.push(assertion.toJSON());
+    } else if (operator === 'not-equal') {
+      const assertion = new NotEqualAssertion();
+      if (predictedValue) {
+        assertion.value = String(predictedValue);
+      }
+      result.steps.push(assertion.toJSON());
+    } else if (operator === 'greater-than') {
+      const assertion = new GreaterThanAssertion();
+      if (predictedValue) {
+        const typed = Number(predictedValue);
+        if (!Number.isNaN(typed)) {
+          assertion.value = typed;
+        }
+      }
+      result.steps.push(assertion.toJSON());
+    } else if (operator === 'greater-than-equal') {
+      const assertion = new GreaterThanAssertion();
+      assertion.equal = true;
+      if (predictedValue) {
+        const typed = Number(predictedValue);
+        if (!Number.isNaN(typed)) {
+          assertion.value = typed;
+        }
+      }
+      result.steps.push(assertion.toJSON());
+    } else if (operator === 'less-than') {
+      const assertion = new LessThanAssertion();
+      if (predictedValue) {
+        const typed = Number(predictedValue);
+        if (!Number.isNaN(typed)) {
+          assertion.value = typed;
+        }
+      }
+      result.steps.push(assertion.toJSON());
+    } else if (operator === 'less-than-equal') {
+      const assertion = new LessThanAssertion();
+      assertion.equal = true;
+      if (predictedValue) {
+        const typed = Number(predictedValue);
+        if (!Number.isNaN(typed)) {
+          assertion.value = typed;
+        }
+      }
+      result.steps.push(assertion.toJSON());
+    } else if (operator === 'regex') {
+      const assertion = new MatchesAssertion();
+      if (predictedValue) {
+        assertion.value = String(predictedValue);
       }
+      result.steps.push(assertion.toJSON());
     }
     return result;
   }

package/src/models/{http-actions → http-flows}/steps/data/DeleteCookieStep.ts

@@ -33,11 +33,16 @@ export class DeleteCookieStep extends HttpStep {
    */
   name?: string;
 
-  static byName(name: string): DeleteCookieStep {
+  /**
+   * @param name The name of the cookie
+   * @param url Optionally, the URL of the cookie.
+   */
+  static byName(name: string, url?: string): DeleteCookieStep {
     return new DeleteCookieStep({
       kind: DeleteCookieStepKind,
       enabled: true,
       name,
+      url,
     });
   }
 

package/src/models/http-flows/steps/data/DeleteVariableStep.ts

@@ -0,0 +1,78 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const DeleteVariableStepKind = 'HttpAction#DeleteVariable';
+
+/**
+ * A step that deletes a variable.
+ */
+export interface IDeleteVariableStep extends IHttpStep {
+  kind: typeof DeleteVariableStepKind;
+  /**
+   * The name of the variable to delete
+   */
+  name: string;
+}
+
+
+export class DeleteVariableStep extends HttpStep {
+  override kind = DeleteVariableStepKind;
+
+  /**
+   * The name of the variable to delete
+   */
+  name = '';
+
+  /**
+   * Creates the step from values.
+   * @param name The name of the variable to delete
+   */
+  constructor(name: string);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: IDeleteVariableStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(nameOrInit?: string | IDeleteVariableStep) {
+    super();
+    if (!nameOrInit) {
+      return;
+    }
+    if (typeof nameOrInit === 'object') {
+      const typed = nameOrInit as IDeleteVariableStep;
+      this.new(typed);
+    } else if (typeof nameOrInit === 'string') {
+      this.new({
+        kind: DeleteVariableStepKind,
+        name: nameOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IDeleteVariableStep): void {
+    super.new(init);
+    this.kind = DeleteVariableStepKind;
+    this.name = init.name;
+  }
+
+  checkValidity(): boolean {
+    const { name } = this;
+    return !!name;
+  }
+
+  override toJSON(): IDeleteVariableStep {
+    const result: IDeleteVariableStep = {
+      ...super.toJSON(),
+      kind: DeleteVariableStepKind,
+      name: this.name,
+    };
+    return result;
+  }
+}