@api-client/core 0.9.3 → 0.9.5

package/src/models/http-actions/HttpFlows.ts

@@ -0,0 +1,115 @@
+import { AssertionEnum } from './HttpAssertion.js';
+import { IHttpStep } from './HttpStep.js';
+
+export enum FlowSourceEnum {
+  /**
+   * The request object.
+   */
+  request = 'request',
+  /**
+   * The response object.
+   */
+  response = 'response',
+  /**
+   * A variable from the current environment.
+   */
+  variable = 'variable',
+}
+
+export enum FlowRequestDataEnum {
+  url = "url",
+  method = "method",
+  headers = "headers",
+  body = "body"
+}
+
+export enum FlowResponseDataEnum {
+  url = "url",
+  status = "status",
+  statusText = "statusText",
+  headers = "headers",
+  body = "body"
+}
+
+/**
+ * A flow represents a series of actions to be performed one-by-one after the HTTP request is sent or when the response 
+ * is ready.
+ */
+export interface IHttpFlow {
+  /**
+   * The description of the flow
+   */
+  description?: string;
+  /**
+   * Describes when the flow is executed.
+   * The `request` means the flow is executed before the request is sent to the HTTP engine.
+   * The `response` means the flow is executed after the response has been received in full, but before reporting 
+   * the response to the UI.
+   */
+  trigger: 'request' | 'response';
+  /**
+   * The ordered list of actions to execute.
+   */
+  actions: IHttpAction[];
+}
+
+/**
+ * Describes a single action in a flow.
+ * An action can have a condition that is checked against the current context.
+ * Action is not executed when the condition is not meet.
+ * 
+ * Each action has one or more steps (when 0 items then the action is ignored). Each step performs a task.
+ * The result of a task is passed to the next step as an input. The result of a task may be `void`, `null`, or `undefined` which is treated as `void`.
+ */
+export interface IHttpAction {
+  /**
+   * The description of the action
+   */
+  description?: string;
+  /**
+   * A condition to check before performing the action.
+   */
+  condition?: IHttpCondition;
+  /**
+   * The list of steps to perform. This is an ordered list of action tasks.
+   * Each step is described by the `kind` property which tells the runner what action to perform.
+   */
+  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/HttpStep.ts

@@ -0,0 +1,50 @@
+/**
+ * The action that can be taken on the data.
+ */
+export interface IHttpStep {
+  /**
+   * The kind of the action to perform.
+   */
+  kind: string;
+  /**
+   * Whether the step is disabled in the flow.
+   */
+  enabled?: boolean;
+}
+
+export abstract class HttpStep {
+  /**
+   * The kind of the action to perform.
+   */
+  kind = '';
+
+  /**
+   * Whether the step is disabled in the flow.
+   */
+  enabled?: boolean;
+
+  new(init: IHttpStep): void {
+    const { kind, enabled } = init;
+    this.kind = kind;
+    if (typeof enabled === 'boolean') {
+      this.enabled = enabled
+    } else {
+      this.enabled = undefined;
+    }
+  }
+
+  toJSON(): IHttpStep {
+    const result: IHttpStep = {
+      kind: this.kind,
+    }
+    if (typeof this.enabled === 'boolean') {
+      result.enabled = this.enabled;
+    }
+    return result;
+  }
+
+  /**
+   * A function that returns true when the step is valid and can be executed.
+   */
+  abstract checkValidity(): boolean;
+}

package/src/models/http-actions/LegacyTranslator.ts

@@ -1,18 +1,30 @@
 import { RequestActions as LegacyRequestActions } from '../../models/legacy/request/ArcRequest.js';
-import { RunnableAction as LegacyRunnable, Condition as LegacyCondition, Action as LegacyAction, SetCookieConfig, SetVariableConfig, DeleteCookieConfig, DataSourceConfiguration } from '../../models/legacy/actions/Actions.js';
-import { IHttpActionFlow, IHttpAction, IHttpCondition, ActionSourceEnum, ActionRequestDataEnum, ActionResponseDataEnum, ActionOperatorEnum, IActionStep, ISetDataStep, SetDataStepKind, IReadDataStep, ReadDataStepKind, ISetCookieStep, SetCookieStepKind, IDeleteCookieStep, DeleteCookieStepKind } from './HttpActions.js';
+import { 
+  RunnableAction as LegacyRunnable, Condition as LegacyCondition, Action as LegacyAction, 
+  SetCookieConfig, SetVariableConfig, DeleteCookieConfig, DataSourceConfiguration 
+} from '../../models/legacy/actions/Actions.js';
+import { 
+  IHttpFlow, IHttpAction, IHttpCondition, 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 { ISetDataStep, SetDataStepKind } from './steps/data/SetDataStep.js';
+import { ISetCookieStep, SetCookieStepKind } from './steps/data/SetCookieStep.js';
+import { DeleteCookieStepKind, IDeleteCookieStep } from './steps/data/DeleteCookieStep.js';
 
 /**
  * Allows to translate the old ARC actions into Action flows.
  */
 export class LegacyTranslator {
-  static translate(action: LegacyRequestActions): IHttpActionFlow[] {
+  static translate(action: LegacyRequestActions): IHttpFlow[] {
     const { request, response } = action;
-    const result: IHttpActionFlow[] = [];
+    const result: IHttpFlow[] = [];
 
     if (Array.isArray(request) && request.length) {
-      const flow: IHttpActionFlow = {
+      const flow: IHttpFlow = {
         trigger: 'request',
         actions: this._translateRunnables(request),
       };
@@ -20,7 +32,7 @@ export class LegacyTranslator {
     }
 
     if (Array.isArray(response) && response.length) {
-      const flow: IHttpActionFlow = {
+      const flow: IHttpFlow = {
         trigger: 'response',
         actions: this._translateRunnables(response),
       };
@@ -66,16 +78,16 @@ export class LegacyTranslator {
     }
     if (type) {
       switch (type) {
-        case 'request': result.source = ActionSourceEnum.request; break;
-        case 'response': result.source = ActionSourceEnum.response; break;
+        case 'request': result.source = FlowSourceEnum.request; break;
+        case 'response': result.source = FlowSourceEnum.response; break;
       }
     }
     if (type && source) {
       if (type === 'request') {
-        result.data = source as ActionRequestDataEnum;
+        result.data = source as FlowRequestDataEnum;
       }
       if (type === 'response') {
-        result.data = source as ActionResponseDataEnum;
+        result.data = source as FlowResponseDataEnum;
       }
     }
     if (predictedValue) {
@@ -83,20 +95,20 @@ export class LegacyTranslator {
     }
     if (operator) {
       switch (operator) {
-        case 'contains': result.operator = ActionOperatorEnum.contains; break;
-        case 'equal': result.operator = ActionOperatorEnum.equal; break;
-        case 'greater-than': result.operator = ActionOperatorEnum.greaterThan; break;
-        case 'greater-than-equal': result.operator = ActionOperatorEnum.greaterThanEqual; break;
-        case 'less-than': result.operator = ActionOperatorEnum.lessThan; break;
-        case 'less-than-equal': result.operator = ActionOperatorEnum.lessThanEqual; break;
-        case 'not-equal': result.operator = ActionOperatorEnum.notEqual; break;
-        case 'regex': result.operator = ActionOperatorEnum.regex; break;
+        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;
       }
     }
     return result;
   }
 
-  protected static _translateAction(item: LegacyAction): IActionStep[] {
+  protected static _translateAction(item: LegacyAction): IHttpStep[] {
     switch (item.name) {
       case 'set-cookie': return this._translateSetCookieAction(item);
       case 'set-variable': return this._translateSetVariableAction(item);
@@ -105,10 +117,10 @@ export class LegacyTranslator {
     }
   }
 
-  protected static _translateSetCookieAction(item: LegacyAction): IActionStep[] {
+  protected static _translateSetCookieAction(item: LegacyAction): IHttpStep[] {
     const legacy = item.config as SetCookieConfig;
 
-    const steps: IActionStep[] = [];
+    const steps: IHttpStep[] = [];
     const ds = this._translateDataSource(legacy.source);
     steps.push(ds);
 
@@ -142,10 +154,10 @@ export class LegacyTranslator {
     return steps;
   }
 
-  protected static _translateSetVariableAction(item: LegacyAction): IActionStep[] {
+  protected static _translateSetVariableAction(item: LegacyAction): IHttpStep[] {
     const legacy = item.config as SetVariableConfig;
 
-    const steps: IActionStep[] = [];
+    const steps: IHttpStep[] = [];
     const ds = this._translateDataSource(legacy.source);
     steps.push(ds);
 
@@ -161,10 +173,10 @@ export class LegacyTranslator {
     return steps;
   }
 
-  protected static _translateDeleteCookieAction(item: LegacyAction): IActionStep[] {
+  protected static _translateDeleteCookieAction(item: LegacyAction): IHttpStep[] {
     const legacy = item.config as DeleteCookieConfig;
 
-    const steps: IActionStep[] = [];
+    const steps: IHttpStep[] = [];
     
     const action: IDeleteCookieStep = {
       kind: DeleteCookieStepKind,
@@ -183,7 +195,7 @@ export class LegacyTranslator {
     return steps;
   }
 
-  protected static _translateDataSource(source: DataSourceConfiguration): IActionStep {
+  protected static _translateDataSource(source: DataSourceConfiguration): IHttpStep {
     if (source.value) {
       const dataSet: ISetDataStep = {
         kind: SetDataStepKind,
@@ -206,16 +218,16 @@ export class LegacyTranslator {
     }
     if (type) {
       switch (type) {
-        case 'request': result.source = ActionSourceEnum.request; break;
-        case 'response': result.source = ActionSourceEnum.response; break;
+        case 'request': result.source = FlowSourceEnum.request; break;
+        case 'response': result.source = FlowSourceEnum.response; break;
       }
     }
     if (type && legacySource) {
       if (type === 'request') {
-        result.data = legacySource as ActionRequestDataEnum;
+        result.data = legacySource as FlowRequestDataEnum;
       }
       if (type === 'response') {
-        result.data = legacySource as ActionResponseDataEnum;
+        result.data = legacySource as FlowResponseDataEnum;
       }
     }
     return result;

package/src/models/http-actions/steps/assertion/EqualAssertion.ts

@@ -0,0 +1,130 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const EqualAssertionKind = 'HttpAction#EqualAssertion';
+
+/**
+ * An assertion that makes sure the input value is [strict] equal to the set value.
+ */
+export interface IEqualAssertion extends IHttpStep {
+  kind: typeof EqualAssertionKind;
+
+  /**
+   * The value to compare to.
+   * This is always a string. Use the `dataType` to determine the correct data type.
+   */
+  value?: string;
+
+  /**
+   * The data type of the value. This is a value prefixed with 
+   * `http://www.w3.org/2001/XMLSchema#` or `http://a.ml/vocabularies/shapes#`.
+   * 
+   * Examples:
+   * 
+   * - `http://www.w3.org/2001/XMLSchema#boolean`
+   * - `http://www.w3.org/2001/XMLSchema#string`
+   * - `http://www.w3.org/2001/XMLSchema#number`
+   * - `http://www.w3.org/2001/XMLSchema#integer`
+   * - `http://www.w3.org/2001/XMLSchema#long`
+   * - `http://a.ml/vocabularies/shapes#number`
+   * - `http://a.ml/vocabularies/shapes#integer`
+   * - `http://a.ml/vocabularies/shapes#double`
+   * - ...
+   * 
+   * @default `http://www.w3.org/2001/XMLSchema#string`
+   */
+  dataType?: string;
+
+  /**
+   * Whether it should check for a value and the data type.
+   */
+  strict?: boolean;
+}
+
+/**
+ * An assertion that makes sure the input value is [strict] equal to the set value.
+ */
+export class EqualAssertion extends HttpStep {
+  override kind = EqualAssertionKind;
+
+  /**
+   * The value to compare to.
+   * This is always a string. Use the `dataType` to determine the correct data type.
+   */
+  value?: string;
+
+  /**
+   * The data type of the value. This is a value prefixed with 
+   * `http://www.w3.org/2001/XMLSchema#` or `http://a.ml/vocabularies/shapes#`.
+   * 
+   * Examples:
+   * 
+   * - `http://www.w3.org/2001/XMLSchema#boolean`
+   * - `http://www.w3.org/2001/XMLSchema#string`
+   * - `http://www.w3.org/2001/XMLSchema#number`
+   * - `http://www.w3.org/2001/XMLSchema#integer`
+   * - `http://www.w3.org/2001/XMLSchema#long`
+   * - `http://a.ml/vocabularies/shapes#number`
+   * - `http://a.ml/vocabularies/shapes#integer`
+   * - `http://a.ml/vocabularies/shapes#double`
+   * - ...
+   * 
+   * @default `http://www.w3.org/2001/XMLSchema#string`
+   */
+  dataType?: string;
+
+  /**
+   * Whether it should check for a value and the data type.
+   */
+  strict?: boolean;
+
+  constructor(value: string, strict?: boolean, dataType?: string);
+
+  constructor(init: IEqualAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: IEqualAssertion | string, strict?: boolean, dataType?: string) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as IEqualAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: EqualAssertionKind,
+        value: valueOrInit,
+        dataType,
+        strict,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IEqualAssertion): void {
+    super.new(init);
+    this.kind = EqualAssertionKind;
+    this.value = init.value;
+    this.dataType = init.dataType;
+    this.strict = init.strict;
+  }
+
+  checkValidity(): boolean {
+    return !!this.value;
+  }
+
+  override toJSON(): IEqualAssertion {
+    const result: IEqualAssertion = {
+      ...super.toJSON(),
+      kind: EqualAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    if (this.dataType) {
+      result.dataType = this.dataType;
+    }
+    if (typeof this.strict === 'boolean') {
+      result.strict = this.strict;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/GreaterThanAssertion.ts

@@ -0,0 +1,87 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const GreaterThanAssertionKind = 'HttpAction#GreaterThanAssertion';
+
+/**
+ * An assertion that makes sure the input value is greater [or equal] to the set value.
+ */
+export interface IGreaterThanAssertion extends IHttpStep {
+  kind: typeof GreaterThanAssertionKind;
+
+  /**
+   * The value to compare to.
+   */
+  value?: number;
+
+  /**
+   * When set it treats the assertion as "greater than or equal"
+   */
+  equal?: boolean;
+}
+
+/**
+ * An assertion that makes sure the input value is greater [or equal] to the set value.
+ */
+export class GreaterThanAssertion extends HttpStep {
+  override kind = GreaterThanAssertionKind;
+
+  /**
+   * The value to compare to.
+   */
+  value?: number;
+
+  /**
+   * When set it treats the assertion as "greater than or equal"
+   */
+  equal?: boolean;
+
+  constructor(value: number, equal?: boolean);
+
+  constructor(init: IGreaterThanAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: IGreaterThanAssertion | number, equal?: boolean) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as IGreaterThanAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'number') {
+      this.new({
+        kind: GreaterThanAssertionKind,
+        value: valueOrInit,
+        equal,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IGreaterThanAssertion): void {
+    super.new(init);
+    this.kind = GreaterThanAssertionKind;
+    this.value = init.value;
+    if (typeof init.equal === 'boolean') {
+      this.equal = init.equal;
+    } else {
+      this.equal = undefined;
+    }
+  }
+
+  checkValidity(): boolean {
+    return typeof this.value === 'number';
+  }
+
+  override toJSON(): IGreaterThanAssertion {
+    const result: IGreaterThanAssertion = {
+      ...super.toJSON(),
+      kind: GreaterThanAssertionKind,
+    };
+    if (typeof this.value === 'number') {
+      result.value = this.value;
+    }
+    if (typeof this.equal === 'boolean') {
+      result.equal = this.equal;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/IncludesAssertion.ts

@@ -0,0 +1,68 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const IncludesAssertionKind = 'HttpAction#IncludesAssertion';
+
+/**
+ * An assertion that makes sure the input includes the set value.
+ */
+export interface IIncludesAssertion extends IHttpStep {
+  kind: typeof IncludesAssertionKind;
+
+  /**
+   * The value to search for.
+   */
+  value?: string;
+}
+
+/**
+ * An assertion that makes sure the input includes the set value.
+ */
+export class IncludesAssertion extends HttpStep {
+  override kind = IncludesAssertionKind;
+
+  /**
+   * The value to search for.
+   */
+  value?: string;
+
+  constructor(value: string);
+
+  constructor(init: IIncludesAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: IIncludesAssertion | string) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as IIncludesAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: IncludesAssertionKind,
+        value: valueOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IIncludesAssertion): void {
+    super.new(init);
+    this.kind = IncludesAssertionKind;
+    this.value = init.value;
+  }
+
+  checkValidity(): boolean {
+    return !!this.value;
+  }
+
+  override toJSON(): IIncludesAssertion {
+    const result: IIncludesAssertion = {
+      ...super.toJSON(),
+      kind: IncludesAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/IsEmptyAssertion.ts

@@ -0,0 +1,41 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const IsEmptyAssertionKind = 'HttpAction#IsEmptyAssertion';
+
+/**
+ * An assertion that makes sure the input is empty (empty array, empty string, empty object - no properties)
+ */
+export interface IIsEmptyAssertion extends IHttpStep {
+  kind: typeof IsEmptyAssertionKind;
+}
+
+/**
+ * An assertion that makes sure the input is empty (empty array, empty string, empty object - no properties)
+ */
+export class IsEmptyAssertion extends HttpStep {
+  override kind = IsEmptyAssertionKind;
+
+  constructor(init?: IIsEmptyAssertion) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IIsEmptyAssertion): void {
+    super.new(init);
+    this.kind = IsEmptyAssertionKind;
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IIsEmptyAssertion {
+    const result: IIsEmptyAssertion = {
+      ...super.toJSON(),
+      kind: IsEmptyAssertionKind,
+    };
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/IsNotEmptyAssertion.ts

@@ -0,0 +1,41 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const IsNotEmptyAssertionKind = 'HttpAction#IsNotEmptyAssertion';
+
+/**
+ * An assertion that makes sure the input is empty (empty array, empty string, empty object - no properties)
+ */
+export interface IIsNotEmptyAssertion extends IHttpStep {
+  kind: typeof IsNotEmptyAssertionKind;
+}
+
+/**
+ * An assertion that makes sure the input is empty (empty array, empty string, empty object - no properties)
+ */
+export class IsNotEmptyAssertion extends HttpStep {
+  override kind = IsNotEmptyAssertionKind;
+
+  constructor(init?: IIsNotEmptyAssertion) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IIsNotEmptyAssertion): void {
+    super.new(init);
+    this.kind = IsNotEmptyAssertionKind;
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IIsNotEmptyAssertion {
+    const result: IIsNotEmptyAssertion = {
+      ...super.toJSON(),
+      kind: IsNotEmptyAssertionKind,
+    };
+    return result;
+  }
+}