@api-client/core 0.3.1 → 0.3.4

package/src/models/actions/Action.ts

@@ -0,0 +1,213 @@
+import { IActions } from './runnable/index.js';
+import { Runnable, IRunnable } from './runnable/Runnable.js';
+import { Kind as DeleteCookieKind, DeleteCookieAction, IDeleteCookieAction } from './runnable/DeleteCookieAction.js';
+import { Kind as SetCookieKind, SetCookieAction, ISetCookieAction } from './runnable/SetCookieAction.js';
+import { Kind as SetVariableKind, SetVariableAction, ISetVariableAction } from './runnable/SetVariableAction.js';
+import { Action as LegacyAction, SetCookieConfig, SetVariableConfig, DeleteCookieConfig } from '../legacy/actions/Actions.js';
+
+export const Kind = 'ARC#Action';
+
+/**
+ * An interface representing a single action.
+ */
+export interface IAction {
+  kind?: 'ARC#Action';
+  /**
+   * Action name.
+   */
+  name?: string;
+  /**
+   * Whether the action is enabled.
+   * An action is enabled by default.
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Action priority. The higher number the higher priority of execution.
+   */
+  priority?: number;
+  /**
+   * The action configuration. The schema depends on the action type.
+   */
+  config?: unknown;
+  /**
+   * Whether or not the action is executed synchronously to request / response
+   */
+  sync?: boolean;
+  /**
+   * Whether or not the request should fail when the action fails.
+   */
+  failOnError?: boolean;
+}
+
+export class Action {
+  kind = Kind;
+  /**
+   * Action name.
+   */
+  name?: string;
+  /**
+   * Whether the action is enabled.
+   */
+  enabled?: boolean;
+  /**
+   * Action priority. The higher number the higher priority of execution.
+   */
+  priority?: number;
+  /**
+   * Action configuration
+   */
+  config?: Runnable;
+  /**
+   * Whether or not the action is executed synchronously to request / response
+   */
+  sync?: boolean;
+  /**
+   * Whether or not the request should fail when the action fails.
+   */
+  failOnError?: boolean;
+
+  static fromLegacy(item: LegacyAction): Action {
+    const { priority, config, enabled, failOnError, name, sync } = item;
+    let newConfig: IRunnable | undefined;
+    switch (name) {
+      case 'set-cookie': newConfig = SetCookieAction.fromLegacy(config as SetCookieConfig).toJSON(); break;
+      case 'set-variable': newConfig = SetVariableAction.fromLegacy(config as SetVariableConfig); break;
+      case 'delete-cookie': newConfig = DeleteCookieAction.fromLegacy(config as DeleteCookieConfig); break;
+    }
+    
+    const init: IAction = {
+      kind: Kind,
+      priority,
+    };
+    if (typeof enabled === 'boolean') {
+      init.enabled = enabled;
+    }
+    if (typeof failOnError === 'boolean') {
+      init.failOnError = failOnError;
+    }
+    if (typeof sync === 'boolean') {
+      init.sync = sync;
+    }
+    if (typeof name === 'string') {
+      init.name = name;
+    }
+    if (newConfig) {
+      init.config = newConfig;
+    }
+    return new Action(init);
+  }
+
+  /**
+   * Creates a default configuration of an action
+   */
+  static defaultAction(): Action {
+    const init: IAction = {
+      name: 'New action',
+      failOnError: false,
+      priority: 0,
+      sync: false,
+      enabled: true,
+    };
+    return new Action(init);
+  }
+
+  constructor(input?: string | IAction) {
+    let init: IAction;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: IAction): void {
+    const { name, enabled, priority, sync, failOnError, config } = init;
+    this.kind = Kind;
+    if (name) {
+      this.name = name;
+    } else {
+      this.name = undefined;
+    }
+    if (typeof enabled === 'boolean') {
+      this.enabled = enabled;
+    } else {
+      this.enabled = undefined;
+    }
+    if (typeof sync === 'boolean') {
+      this.sync = sync;
+    } else {
+      this.sync = undefined;
+    }
+    if (typeof failOnError === 'boolean') {
+      this.failOnError = failOnError;
+    } else {
+      this.failOnError = undefined;
+    }
+    if (typeof priority === 'number') {
+      this.priority = priority;
+    } else {
+      this.priority = undefined;
+    }
+    if (config) {
+      this.setConfig(config);
+    } else {
+      this.config = undefined;
+    }
+  }
+
+  toJSON(): IAction {
+    const result: IAction = {
+      kind: Kind,
+    };
+    if (this.name) {
+      result.name = this.name;
+    }
+    if (this.config) {
+      result.config = this.config.toJSON() as IActions;
+    }
+    if (typeof this.enabled === 'boolean') {
+      result.enabled = this.enabled;
+    }
+    if (typeof this.sync === 'boolean') {
+      result.sync = this.sync;
+    }
+    if (typeof this.failOnError === 'boolean') {
+      result.failOnError = this.failOnError;
+    }
+    if (typeof this.priority === 'number') {
+      result.priority = this.priority;
+    }
+    return result;
+  }
+
+  setConfig(config: unknown): void {
+    const { kind } = config as IRunnable;
+    switch (kind) {
+      case DeleteCookieKind: this.config = new DeleteCookieAction(config as IDeleteCookieAction); break;
+      case SetCookieKind: this.config = new SetCookieAction(config as ISetCookieAction); break;
+      case SetVariableKind: this.config = new SetVariableAction(config as ISetVariableAction); break;
+      default: throw new Error(`Unknown action config.`)
+    }
+  }
+
+  /**
+   * The sort function for actions to sort them for the execution order.
+   */
+  static sortActions(a: Action, b: Action): number {
+    const { priority: p1=0 } = a;
+    const { priority: p2=0 } = b;
+    if (p1 > p2) {
+      return 1;
+    }
+    if (p2 > p1) {
+      return -1;
+    }
+    return 0;
+  }
+}

package/src/models/actions/ActionView.ts

@@ -0,0 +1,40 @@
+export interface IActionView {
+  /**
+   * Whether the action is "opened" in the editor UI.
+   */
+  opened?: boolean;
+}
+
+export class ActionView {
+  /**
+   * Whether the action is "opened" in the editor UI.
+   */
+  opened?: boolean;
+
+  constructor(input?: string|IActionView) {
+    let init: IActionView;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        opened: false,
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: IActionView): void {
+    const { opened=false } = init;
+    this.opened = opened;
+  }
+
+  toJSON(): IActionView {
+    const result: IActionView = {};
+    if (typeof this.opened === 'boolean') {
+      result.opened = this.opened;
+    }
+    return result;
+  }
+}

package/src/models/actions/Condition.ts

@@ -0,0 +1,207 @@
+import { ActionTypeEnum, RequestDataSourceEnum, ResponseDataSourceEnum, OperatorEnum } from './Enums.js';
+import { Condition as LegacyCondition } from '../legacy/actions/Actions.js';
+
+export const Kind = 'ARC#Condition';
+
+/**
+ * A base interface describing a configuration to extract data from a request or a response.
+ */
+export interface IDataSource {
+  /**
+   * The main data source. Either the request or the response object.
+   * This is required when the `source` is not equal to `value. In this case it is ignored
+   */
+  type?: ActionTypeEnum;
+  /**
+   * Source of the data.
+   */
+  source: RequestDataSourceEnum | ResponseDataSourceEnum | 'value';
+  /**
+   * 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;
+  /**
+   * Only used when the `source` is `value`. The data extraction always returns this value.
+   */
+  value?: string;
+}
+
+/**
+ * Describes action's condition configuration.
+ */
+export interface ICondition extends IDataSource {
+  kind: 'ARC#Condition',
+  /**
+   * The comparison operator.
+   */
+  operator?: OperatorEnum;
+  /**
+   * Whether the condition always pass.
+   * The condition is not really checked, values can be empty. The condition check always returns `true`.
+   */
+  alwaysPass?: boolean;
+}
+
+export class Condition {
+  kind = Kind;
+  /**
+   * The main data source. Either the request or the response object.
+   * This is required when the `source` is not equal to `value. In this case it is ignored
+   */
+  type?: ActionTypeEnum;
+  /**
+   * Source of the data.
+   */
+  source: RequestDataSourceEnum | ResponseDataSourceEnum | 'value' = RequestDataSourceEnum.url;
+  /** 
+   * 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;
+  /**
+   * Only used when the `source` is `value`. The data extraction always returns this value.
+   */
+  value?: string;
+  /**
+   * The comparison operator.
+   */
+  operator?: OperatorEnum;
+  /**
+   * Whether the condition always pass.
+   * The condition is not really checked, values can be empty. The condition check always returns `true`.
+   */
+  alwaysPass?: boolean;
+
+  static defaultCondition(type=ActionTypeEnum.response): Condition {
+    const init: ICondition = {
+      kind: Kind,
+      type,
+      source: RequestDataSourceEnum.url,
+      operator: OperatorEnum.equal,
+      path: '',
+      alwaysPass: false,
+    };
+    return new Condition(init);
+  }
+
+  static fromLegacy(runnable: LegacyCondition): Condition {
+    const { source, alwaysPass, operator, path, predictedValue, type, value } = runnable;
+    const init: ICondition = {
+      kind: Kind,
+      source: source as RequestDataSourceEnum | ResponseDataSourceEnum | 'value',
+    };
+    if (typeof alwaysPass === 'boolean') {
+      init.alwaysPass = alwaysPass;
+    }
+    if (typeof path === 'string') {
+      init.path = path;
+    }
+    if (path === 'value') {
+      init.value = String(value);
+    } else {
+      init.value = String(predictedValue);
+    }
+    if (operator) {
+      switch (operator) {
+        case 'contains': init.operator = OperatorEnum.contains; break;
+        case 'equal': init.operator = OperatorEnum.equal; break;
+        case 'greater-than': init.operator = OperatorEnum.greaterThan; break;
+        case 'greater-than-equal': init.operator = OperatorEnum.greaterThanEqual; break;
+        case 'less-than': init.operator = OperatorEnum.lessThan; break;
+        case 'less-than-equal': init.operator = OperatorEnum.lessThanEqual; break;
+        case 'not-equal': init.operator = OperatorEnum.notEqual; break;
+        case 'regex': init.operator = OperatorEnum.regex; break;
+      }
+    }
+    if (type) {
+      switch (type) {
+        case 'request': init.type = ActionTypeEnum.request; break;
+        case 'response': init.type = ActionTypeEnum.response; break;
+      }
+    }
+    return new Condition(init);
+  }
+
+  static alwaysPass(type=ActionTypeEnum.request): Condition {
+    const init: ICondition = {
+      kind: Kind,
+      type,
+      source: 'value',
+      alwaysPass: true,
+    };
+    return new Condition(init);
+  }
+
+  constructor(input?: string | ICondition) {
+    let init: ICondition;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        source: RequestDataSourceEnum.url,
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: ICondition): void {
+    const { source = RequestDataSourceEnum.url, alwaysPass, operator, path, type, value } = init;
+    this.source = source;
+    if (typeof alwaysPass === 'boolean') {
+      this.alwaysPass = alwaysPass;
+    } else {
+      this.alwaysPass = undefined;
+    }
+    if (operator) {
+      this.operator = operator;
+    } else {
+      this.operator = undefined;
+    }
+    if (typeof path === 'string') {
+      this.path = path;
+    } else {
+      this.path = undefined;
+    }
+    if (type) {
+      this.type = type;
+    } else {
+      this.type = undefined;
+    }
+    if (value) {
+      this.value = value;
+    } else {
+      this.value = undefined;
+    }
+  }
+
+  toJSON(): ICondition {
+    const result: ICondition = {
+      source: this.source,
+      kind: Kind,
+    };
+    if (this.type) {
+      result.type = this.type;
+    }
+    if (this.path) {
+      result.path = this.path;
+    }
+    if (this.value) {
+      result.value = this.value;
+    }
+    if (this.operator) {
+      result.operator = this.operator;
+    }
+    if (typeof this.alwaysPass === 'boolean') {
+      result.alwaysPass = this.alwaysPass;
+    }
+    return result;
+  }
+}

package/src/models/actions/ConditionView.ts

@@ -0,0 +1,42 @@
+export interface IConditionView {
+  /**
+   * Whether the condition editor is rendered in the "full" view
+   * instead of the summary.
+   */
+  opened?: boolean;
+}
+
+export class ConditionView {
+  /**
+   * Whether the condition editor is rendered in the "full" view
+   * instead of the summary.
+   */
+  opened?: boolean;
+
+  constructor(input?: string|IConditionView) {
+    let init: IConditionView;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        opened: false,
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: IConditionView): void {
+    const { opened=false } = init;
+    this.opened = opened;
+  }
+
+  toJSON(): IConditionView {
+    const result: IConditionView = {};
+    if (typeof this.opened === 'boolean') {
+      result.opened = this.opened;
+    }
+    return result;
+  }
+}

package/src/models/actions/Enums.ts

@@ -0,0 +1,29 @@
+export enum ActionTypeEnum {
+  request = 'request',
+  response = 'response',
+}
+
+export enum OperatorEnum {
+  equal = "equal",
+  notEqual = "not-equal",
+  greaterThan = "greater-than",
+  greaterThanEqual = "greater-than-equal",
+  lessThan = "less-than",
+  lessThanEqual = "less-than-equal",
+  contains = "contains",
+  regex = "regex",
+}
+
+export enum RequestDataSourceEnum {
+  url = "url",
+  method = "method",
+  headers = "headers",
+  body = "body"
+}
+
+export enum ResponseDataSourceEnum {
+  url = "url",
+  status = "status",
+  headers = "headers",
+  body = "body"
+}

package/src/models/actions/RunnableAction.ts

@@ -0,0 +1,144 @@
+import { ICondition, Condition } from './Condition.js';
+import { IAction, Action } from './Action.js';
+import { RunnableAction as LegacyRunnable } from '../legacy/actions/Actions.js';
+
+export const Kind = 'ARC#RunnableAction';
+
+/**
+ * An interface representing a runnable set of action in a condition.
+ * For the actions to be executed the condition first has to be met.
+ * The condition can be configured to always pass by setting the `alwaysPass` property.
+ */
+export interface IRunnableAction {
+  kind?: typeof Kind;
+  /**
+   * The condition to be checked when executing the runnable,
+   */
+  condition: ICondition;
+  /**
+   * The list of actions to execute.
+   */
+  actions: IAction[];
+  /**
+   * Whether the entire runnable is enabled. This is checked before the condition is executed.
+   * An action is enabled by default.
+   */
+  enabled?: boolean;
+}
+
+export class RunnableAction {
+  kind = Kind;
+  /**
+   * The condition to be checked when executing the runnable,
+   */
+  condition: Condition = new Condition();
+  /**
+   * The list of actions to execute.
+   */
+  actions: Action[] = [];
+  /**
+   * Whether the entire runnable is enabled. This is checked before the condition is executed.
+   */
+  enabled?: boolean;
+
+  static fromLegacy(runnable: LegacyRunnable): RunnableAction {
+    const result = new RunnableAction();
+    result.fromLegacy(runnable);
+    return result;
+  }
+
+  constructor(input?: string | IRunnableAction) {
+    let init: IRunnableAction;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        condition: new Condition().toJSON(),
+        actions: [],
+        enabled: true,
+      };
+    }
+    if (init.kind === Kind) {
+      this.new(init);
+    } else {
+      this.fromLegacy((init as unknown) as LegacyRunnable);
+    }
+  }
+
+  new(init: IRunnableAction): void {
+    const { enabled, condition, actions } = init;
+    this.enabled = enabled;
+    if (condition) {
+      this.condition = new Condition(condition);
+    } else {
+      this.condition = new Condition();
+    }
+    if (Array.isArray(actions)) {
+      this.actions = actions.map(i => new Action(i));
+    } else {
+      this.actions = [];
+    }
+  }
+
+  toJSON(): IRunnableAction {
+    const result: IRunnableAction = {
+      condition: this.condition.toJSON(),
+      actions: this.actions.map(i => i.toJSON()),
+      kind: Kind,
+    };
+    if (typeof this.enabled === 'boolean') {
+      result.enabled = this.enabled;
+    }
+    return result;
+  }
+
+  fromLegacy(runnable: LegacyRunnable): void {
+    const { actions, condition, enabled } = runnable;
+    if (typeof enabled === 'boolean') {
+      this.enabled = enabled;
+    }
+    if (condition) {
+      this.condition = Condition.fromLegacy(condition);
+    } else {
+      this.condition = new Condition();
+    }
+    if (Array.isArray(actions) && actions.length) {
+      this.actions = actions.map(i => Action.fromLegacy(i));
+    } else {
+      this.actions = [];
+    }
+  }
+
+  /**
+   * Adds a new action to the list of runnable action.
+   * 
+   * @param schema The schema of the action
+   * @returns Created instance of the action.
+   */
+  addAction(schema: IAction): Action;
+
+  /**
+   * Adds a new action to the list of runnable action.
+   * 
+   * @param schema The instance of the action
+   * @returns The same instance of the action.
+   */
+  addAction(instance: Action): Action;
+  
+  addAction(value: Action | IAction): Action {
+    if (!Array.isArray(this.actions)) {
+      this.actions = [];
+    }
+    let finalAction: Action;
+    if (value instanceof Action) {
+      finalAction = value;
+    } else {
+      finalAction = new Action(value);
+    }
+    this.actions.push(finalAction);
+    return finalAction;
+  }
+}