@api-client/core 0.3.1 → 0.3.4

package/src/runtime/actions/ActionRunner.ts

@@ -0,0 +1,83 @@
+import { Action } from '../../models/actions/Action.js';
+import { Runnable as ModelRunnable } from '../../models/actions/runnable/Runnable.js';
+import { IHttpRequest } from '../../models/HttpRequest.js';
+import { IRequestLog } from '../../models/RequestLog.js';
+import { Kind as DeleteCookieKind } from '../../models/actions/runnable/DeleteCookieAction.js';
+import { Kind as SetCookieKind } from '../../models/actions/runnable/SetCookieAction.js';
+import { Kind as SetVariableKind } from '../../models/actions/runnable/SetVariableAction.js';
+import { ActionRunnable } from './runnable/ActionRunnable.js';
+import { DeleteCookieRunnable } from './runnable/DeleteCookieRunnable.js';
+import { SetCookieRunnable } from './runnable/SetCookieRunnable.js';
+import { SetVariableRunnable } from './runnable/SetVariableRunnable.js';
+
+/**
+ * A class that is responsible for running a single action.
+ */
+export class ActionRunner {
+  action: Action;
+  eventTarget: EventTarget;
+
+  constructor(action: Action, eventTarget: EventTarget) {
+    this.action = action;
+    this.eventTarget = eventTarget;
+  }
+
+  async request(request: IHttpRequest): Promise<void> {
+    const runnable = this.getActionRunnable();
+    if (!runnable) {
+      throw new Error(`Invalid action configuration. The runnable configuration is not defined.`);
+    }
+    const { action } = this;
+    if (action.sync === false) {
+      this.requestAsync(runnable, request);
+      return;
+    }
+    await runnable.request(request);
+  }
+
+  async requestAsync(runnable: ActionRunnable, request: IHttpRequest): Promise<void> {
+    const { action } = this;
+    try {
+      await runnable.request(request);
+    } catch (e) {
+      const err = e as Error;
+      console.error(`Unable to run a request action: ${action.name || 'unknown name'}: ${err.message}`);
+    }
+  }
+
+  getActionRunnable(): ActionRunnable | undefined {
+    const { action, eventTarget } = this;
+    const config = action.config as ModelRunnable;
+    if (!config) {
+      return;
+    }
+    switch (config.kind) {
+      case DeleteCookieKind: return new DeleteCookieRunnable(config.toJSON(), eventTarget);
+      case SetCookieKind: return new SetCookieRunnable(config.toJSON(), eventTarget);
+      case SetVariableKind: return new SetVariableRunnable(config.toJSON(), eventTarget);
+    }
+  }
+
+  async response(log: IRequestLog): Promise<void> {
+    const runnable = this.getActionRunnable();
+    if (!runnable) {
+      throw new Error(`Invalid action configuration. The runnable configuration is not defined.`);
+    }
+    const { action } = this;
+    if (action.sync === false) {
+      this.responseAsync(runnable, log);
+      return;
+    }
+    await runnable.response(log);
+  }
+
+  async responseAsync(runnable: ActionRunnable, log: IRequestLog): Promise<void> {
+    const { action } = this;
+    try {
+      await runnable.response(log);
+    } catch (e) {
+      const err = e as Error;
+      console.error(`Unable to run a response action: ${action.name || 'unknown name'}: ${err.message}`);
+    }
+  }
+}

package/src/runtime/actions/ConditionRunner.ts

@@ -0,0 +1,194 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { OperatorEnum } from '../../models/actions/Enums.js';
+
+/**
+ * Checks if values equal.
+ * @param value Value to compare
+ * @param condition Comparator value
+ * @returns True if objects matches.
+ */
+export function isEqual(value: any, condition: any): boolean {
+  if (value === condition) {
+    return true;
+  }
+  let valueTyped = value;
+  let conditionTyped = condition;
+  if (typeof value !== 'undefined') {
+    valueTyped = String(value);
+  }
+  if (typeof condition !== 'undefined') {
+    conditionTyped = String(condition);
+  }
+  const typedConditionNumber = Number(conditionTyped);
+  if (!Number.isNaN(typedConditionNumber)) {
+    conditionTyped = typedConditionNumber;
+    valueTyped = Number(valueTyped);
+  }
+  return conditionTyped === valueTyped;
+}
+
+/**
+ * Opposite of `isEqual()`.
+ *
+ * @param value Value to compare
+ * @param condition Comparator value
+ * @return False if objects matches.
+ */
+export function isNotEqual(value: any, condition: any): boolean {
+  return !isEqual(value, condition);
+}
+
+/**
+ * Checks if value is less than comparator.
+ *
+ * @param value Value to compare
+ * @param condition Comparator value
+ * @returns True if value is less than condition.
+ */
+export function isLessThan(value: any, condition: any): boolean {
+  const valueNumber = Number(value);
+  if (Number.isNaN(valueNumber)) {
+    return false;
+  }
+  const conditionNumber = Number(condition);
+  if (Number.isNaN(conditionNumber)) {
+    return false;
+  }
+  return valueNumber < conditionNumber;
+}
+
+/**
+ * Checks if value is less than or equal to comparator.
+ *
+ * @param value Value to compare
+ * @param condition Comparator value
+ * @returns True if value is less than or equal to `condition`.
+ */
+export function isLessThanEqual(value: any, condition: any): boolean {
+  const valueNumber = Number(value);
+  if (Number.isNaN(valueNumber)) {
+    return false;
+  }
+  const conditionNumber = Number(condition);
+  if (Number.isNaN(conditionNumber)) {
+    return false;
+  }
+  return valueNumber <= conditionNumber;
+}
+
+/**
+ * Checks if value is greater than comparator.
+ *
+ * @param value Value to compare
+ * @param condition Comparator value
+ * @returns True if value is greater than `condition`.
+ */
+export function isGreaterThan(value: any, condition: any): boolean {
+  const valueNumber = Number(value);
+  if (Number.isNaN(valueNumber)) {
+    return false;
+  }
+  const conditionNumber = Number(condition);
+  if (Number.isNaN(conditionNumber)) {
+    return false;
+  }
+  return valueNumber > conditionNumber;
+}
+
+/**
+ * Checks if value is greater than or equal to comparator.
+ *
+ * @param value Value to compare
+ * @param condition Comparator value
+ * @returns True if value is greater than or equal to `condition`.
+ */
+export function isGreaterThanEqual(value: any, condition: any): boolean {
+  const valueNumber = Number(value);
+  if (Number.isNaN(valueNumber)) {
+    return false;
+  }
+  const conditionNumber = Number(condition);
+  if (Number.isNaN(conditionNumber)) {
+    return false;
+  }
+  return valueNumber >= conditionNumber;
+}
+
+/**
+ * Checks if value contains the `condition`.
+ * It works on strings, arrays and objects.
+ *
+ * @param value Value to compare
+ * @param condition Comparator value
+ * @returns True if value contains the `condition`.
+ */
+export function contains(value: any, condition: any): boolean {
+  if (!value) {
+    return false;
+  }
+  if (typeof value === 'string') {
+    return value.indexOf(condition) !== -1;
+  }
+  if (Array.isArray(value)) {
+    if (!Number.isNaN(condition) && typeof condition !== 'number') {
+      const result = value.indexOf(Number(condition));
+      if (result !== -1) {
+        return true;
+      }
+    }
+    return value.indexOf(condition) !== -1;
+  }
+  if (typeof value !== 'object') {
+    return false;
+  }
+  return condition in value;
+}
+
+/**
+ * Checks if `value` can be tested against regular expression.
+ *
+ * @param value Value to compare
+ * @param condition Comparator value - regex string.
+ * @returns Value of calling `test()` function on string.
+ */
+export function isRegex(value: any, condition: any): boolean {
+  let re;
+  try {
+    re = new RegExp(condition, 'm');
+  } catch (e) {
+    return false;
+  }
+  const result = String(value);
+  return re.test(result);
+}
+
+/**
+ * Checks if given condition is satisfied by both value and operator.
+ *
+ * @param value Value read from the response / request object
+ * @param operator Comparison term.
+ * @param condition Value to compare.
+ * @returns True if the condition is satisfied and false otherwise.
+ */
+export function checkCondition(value: any, operator: OperatorEnum, condition: string | number): boolean {
+  switch (operator) {
+    case 'equal':
+      return isEqual(value, condition);
+    case 'not-equal':
+      return isNotEqual(value, condition);
+    case 'greater-than':
+      return isGreaterThan(value, condition);
+    case 'greater-than-equal':
+      return isGreaterThanEqual(value, condition);
+    case 'less-than':
+      return isLessThan(value, condition);
+    case 'less-than-equal':
+      return isLessThanEqual(value, condition);
+    case 'contains':
+      return contains(value, condition);
+    case 'regex':
+      return isRegex(value, condition);
+    default:
+      return false;
+  }
+}

package/src/runtime/actions/RunnableCondition.ts

@@ -0,0 +1,57 @@
+import { IRunnableAction, RunnableAction } from '../../models/actions/RunnableAction.js';
+import { IHttpRequest } from '../../models/HttpRequest.js';
+import { IArcResponse } from '../../models/ArcResponse.js';
+import { ISentRequest } from '../../models/SentRequest.js';
+import { IErrorResponse } from '../../models/ErrorResponse.js';
+import { RequestDataExtractor } from '../../data/RequestDataExtractor.js';
+import { checkCondition } from './ConditionRunner.js';
+
+/**
+ * A class that represents ARC condition that runs actions when the condition is met.
+ */
+export class RunnableCondition extends RunnableAction {
+  /**
+   * Tests whether the condition is satisfied for request and/or response.
+   *
+   * @param request The ARC request object.
+   * @param executed The request object representing the actual request that has been executed by the transport library.
+   * @param response The ARC response object, if available.
+   * @return True when the condition is satisfied.
+   */
+  async satisfied(request: IHttpRequest | ISentRequest, response?: IArcResponse | IErrorResponse): Promise<boolean> {
+    if (this.enabled === false) {
+      return false;
+    }
+    if (this.condition.alwaysPass === true) {
+      return true;
+    }
+    const extractor = new RequestDataExtractor(request, response);
+    const value = await extractor.extract(this.condition);
+    
+    const op = this.condition.operator;
+    if (!op || !this.condition.value) {
+      return false;
+    }
+    return checkCondition(value, op, this.condition.value);
+  }
+}
+
+/**
+ * Maps runnables interface to 
+ * If an item is not an instance of `ArcAction` then it creates an instance of it
+ * by passing the map as an argument.
+ *
+ * @param value Passed list of actions.
+ * @returns Mapped actions.
+ */
+export const mapRunnables = (value: (IRunnableAction | RunnableCondition)[]): RunnableCondition[] => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => {
+    if (!(item instanceof RunnableCondition)) {
+      return new RunnableCondition(item as IRunnableAction);
+    }
+    return item;
+  });
+};

package/src/runtime/actions/runnable/ActionRunnable.ts

@@ -0,0 +1,19 @@
+import { IHttpRequest } from '../../../models/HttpRequest.js';
+import { IRequestLog } from '../../../models/RequestLog.js';
+
+export abstract class ActionRunnable {
+  /**
+   * The specific action configuration.
+   * This depends on the action.
+   */
+  config: unknown;
+  eventTarget: EventTarget;
+
+  constructor(config: unknown, eventTarget: EventTarget) {
+    this.config = Object.freeze(config);
+    this.eventTarget = eventTarget;
+  }
+
+  abstract request(request: IHttpRequest): Promise<void>;
+  abstract response(log: IRequestLog): Promise<void>;
+}

package/src/runtime/actions/runnable/DeleteCookieRunnable.ts

@@ -0,0 +1,39 @@
+import { IHttpRequest } from 'src/models/HttpRequest.js';
+import { ActionRunnable } from './ActionRunnable.js';
+import { IDeleteCookieAction } from '../../../models/actions/runnable/DeleteCookieAction.js';
+import { Events } from '../../../events/Events.js';
+import { IRequestLog } from 'src/models/RequestLog.js';
+
+export class DeleteCookieRunnable extends ActionRunnable {
+  async response(log: IRequestLog): Promise<void> {
+    if (!log.request) {
+      return;
+    }
+    const config = this.config as IDeleteCookieAction;
+    let url;
+    if (config.useRequestUrl) {
+      url = log.request.url;
+    } else {
+      url = config.url;
+    }
+    if (!url) {
+      return;
+    }
+    Events.Cookie.deleteUrl(this.eventTarget, url, config.name);
+  }
+
+  async request(request: IHttpRequest): Promise<void> {
+    const config = this.config as IDeleteCookieAction;
+
+    let url;
+    if (config.useRequestUrl) {
+      url = request.url;
+    } else {
+      url = config.url;
+    }
+    if (!url) {
+      return;
+    }
+    Events.Cookie.deleteUrl(this.eventTarget, url, config.name);
+  } 
+}

package/src/runtime/actions/runnable/SetCookieRunnable.ts

@@ -0,0 +1,92 @@
+import { IHttpRequest } from 'src/models/HttpRequest.js';
+import { IHttpCookie } from 'src/models/HttpCookie.js';
+import { ActionRunnable } from './ActionRunnable.js';
+import { ISetCookieAction } from '../../../models/actions/runnable/SetCookieAction.js';
+import { Events } from '../../../events/Events.js';
+import { RequestDataExtractor } from '../../../data/RequestDataExtractor.js';
+import { IRequestLog } from 'src/models/RequestLog.js';
+
+export class SetCookieRunnable extends ActionRunnable {
+  async request(request: IHttpRequest): Promise<void> {
+    const config = this.config as ISetCookieAction;
+    const value = await this.readRequestValue(request, config);
+    if (typeof value === 'undefined') {
+      throw new Error(`Cannot read value for the action`);
+    }
+    await this.setCookie(request, config, String(value));
+  }
+
+  async readRequestValue(request: IHttpRequest, config: ISetCookieAction): Promise<string | number | undefined> {
+    const { source } = config;
+    let value: string | number | undefined;
+    if (source.source === 'value') {
+      value = source.value;
+    } else {
+      const extractor = new RequestDataExtractor(request);
+      value = await extractor.extract(source);
+    }
+    return value;
+  }
+
+  async setCookie(request: IHttpRequest, config: ISetCookieAction, value: string): Promise<void> {
+    let url;
+    if (config.useRequestUrl) {
+      url = request.url;
+    } else {
+      url = config.url;
+    }
+    if (!url) {
+      throw new Error('The set cookie action has no URL defined.');
+    }
+    const parser = new URL(url);
+    const cookie: IHttpCookie = {
+      name: config.name,
+      value,
+      sameSite: 'unspecified',
+      domain: parser.host, // parser.hostname,
+      path: parser.pathname,
+    };
+    if (config.expires) {
+      const typedNumber = Number(config.expires);
+      if (Number.isNaN(typedNumber)) {
+        const exp = new Date(config.expires);
+        cookie.expirationDate = exp.getTime();
+      } else {
+        const exp = new Date(typedNumber);
+        cookie.expirationDate = exp.getTime();
+      }
+    }
+    if (typeof config.hostOnly === 'boolean') {
+      cookie.hostOnly = config.hostOnly;
+    }
+    if (typeof config.httpOnly === 'boolean') {
+      cookie.httpOnly = config.httpOnly;
+    }
+    if (typeof config.session === 'boolean') {
+      cookie.session = config.session;
+    }
+    if (typeof config.secure === 'boolean') {
+      cookie.secure = config.secure;
+    }
+    Events.Cookie.update(this.eventTarget, cookie);
+  }
+
+  async response(log: IRequestLog): Promise<void> {
+    if (!log.request || !log.response) {
+      return;
+    }
+    const config = this.config as ISetCookieAction;
+    const { source } = config;
+    let value: string | number | undefined;
+    if (source.source === 'value') {
+      value = source.value;
+    } else {
+      const extractor = new RequestDataExtractor(log.request, log.response);
+      value = await extractor.extract(source);
+    }
+    if (typeof value === 'undefined') {
+      throw new Error(`Cannot read value for the action`);
+    }
+    await this.setCookie(log.request, config, String(value));
+  }
+}

package/src/runtime/actions/runnable/SetVariableRunnable.ts

@@ -0,0 +1,53 @@
+import { IHttpRequest } from 'src/models/HttpRequest.js';
+import { ActionRunnable } from './ActionRunnable.js';
+import { ISetVariableAction } from '../../../models/actions/runnable/SetVariableAction.js';
+import { Events } from '../../../events/Events.js';
+import { RequestDataExtractor } from '../../../data/RequestDataExtractor.js';
+import { IRequestLog } from 'src/models/RequestLog.js';
+
+export class SetVariableRunnable extends ActionRunnable {
+  async request(request: IHttpRequest): Promise<void> {
+    const config = this.config as ISetVariableAction;
+    const value = await this.readRequestValue(request, config);
+    if (typeof value === 'undefined') {
+      throw new Error(`Cannot read value for the action`);
+    }
+    await this.setVariable(config, String(value));
+  }
+
+  async readRequestValue(request: IHttpRequest, config: ISetVariableAction): Promise<string | number | undefined> {
+    const { source } = config;
+    let value: string | number | undefined;
+    if (source.source === 'value') {
+      value = source.value;
+    } else {
+      const extractor = new RequestDataExtractor(request);
+      value = await extractor.extract(source);
+    }
+    return value;
+  }
+
+  async setVariable(config: ISetVariableAction, value: string): Promise<void> {
+    const { name } = config;
+    Events.Environment.set(this.eventTarget, name, value);
+  }
+
+  async response(log: IRequestLog): Promise<void> {
+    if (!log.request || !log.response) {
+      return;
+    }
+    const config = this.config as ISetVariableAction;
+    let value: string | number | undefined;
+    const { source } = config;
+    if (source.source === 'value') {
+      value = source.value;
+    } else {
+      const extractor = new RequestDataExtractor(log.request, log.response);
+      value = await extractor.extract(source);
+    }
+    if (typeof value === 'undefined') {
+      throw new Error(`Cannot read value for the action`);
+    }
+    await this.setVariable(config, String(value));
+  }
+}