@api-client/core 0.9.4 → 0.9.6

package/src/models/http-actions/steps/data/ReadDataStep.ts

@@ -0,0 +1,128 @@
+import { FlowRequestDataEnum, FlowResponseDataEnum, FlowSourceEnum } from "../../HttpFlows.js";
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const ReadDataStepKind = 'HttpAction#ReadData';
+
+/**
+ * Reads the data from various sources.
+ */
+export interface IReadDataStep extends IHttpStep {
+  kind: typeof ReadDataStepKind;
+  /**
+   * 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;
+}
+
+export class ReadDataStep extends HttpStep {
+  override kind = ReadDataStepKind;
+
+  /**
+   * 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;
+
+  /**
+   * Creates the step from values.
+   * @param source The main data source.
+   * @param path The path to the data.
+   * @param data Source of the data in the `source`. This is optional for non-http-request source.
+   */
+  constructor(source: FlowSourceEnum, path?: string, data?: FlowRequestDataEnum | FlowResponseDataEnum);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: IReadDataStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(sourceOrInit?: FlowSourceEnum | IReadDataStep, path?: string, data?: FlowRequestDataEnum | FlowResponseDataEnum) {
+    super();
+    if (!sourceOrInit) {
+      return;
+    }
+    if (typeof sourceOrInit === 'object') {
+      const typed = sourceOrInit as IReadDataStep;
+      this.new(typed);
+    } else if (typeof sourceOrInit === 'string') {
+      this.new({
+        kind: ReadDataStepKind,
+        source: sourceOrInit,
+        data,
+        path,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IReadDataStep): void {
+    super.new(init);
+    this.kind = ReadDataStepKind;
+    this.source = init.source;
+    this.data = init.data;
+    this.path = init.path;
+  }
+
+  checkValidity(): boolean {
+    const { source, path, data } = this;
+    if (!source && !path) {
+      return false;
+    }
+    if (source === FlowSourceEnum.variable) {
+      return true;
+    }
+    return !!data;
+  }
+
+  override toJSON(): IReadDataStep {
+    const result: IReadDataStep = {
+      ...super.toJSON(),
+      kind: ReadDataStepKind,
+    };
+    if (this.source) {
+      result.source = this.source;
+    }
+    if (this.data) {
+      result.data = this.data;
+    }
+    if (this.path) {
+      result.path = this.path;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/data/ReadValueStep.ts

@@ -0,0 +1,88 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const ReadValueStepKind = 'HttpAction#ReadValue';
+
+/**
+ * Reads the value for a given path from the input data. This works with the `ReadDataSourceStep`.
+ */
+export interface IReadValueStep extends IHttpStep {
+  kind: typeof ReadValueStepKind;
+  /**
+   * 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;
+}
+
+/**
+ * Reads the value for a given path from the input data. This works with the `ReadDataSourceStep`.
+ */
+export class ReadValueStep extends HttpStep {
+  override kind = ReadValueStepKind;
+
+  /**
+   * 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;
+
+  /**
+   * Creates the step from values.
+   * @param path The path to the data.
+   */
+  constructor(path: string);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: IReadValueStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(pathOrInit?: string | IReadValueStep) {
+    super();
+    if (!pathOrInit) {
+      return;
+    }
+    if (typeof pathOrInit === 'object') {
+      const typed = pathOrInit as IReadValueStep;
+      this.new(typed);
+    } else if (typeof pathOrInit === 'string') {
+      this.new({
+        kind: ReadValueStepKind,
+        path: pathOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IReadValueStep): void {
+    super.new(init);
+    this.kind = ReadValueStepKind;
+    this.path = init.path;
+  }
+
+  checkValidity(): boolean {
+    const { path } = this;
+    return !!path;
+  }
+
+  override toJSON(): IReadValueStep {
+    const result: IReadValueStep = {
+      ...super.toJSON(),
+      kind: ReadValueStepKind,
+    };
+    if (this.path) {
+      result.path = this.path;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/data/SetCookieStep.ts

@@ -0,0 +1,206 @@
+import { SameSiteValue } from "../../../../cookies/CookieParser.js";
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const SetCookieStepKind = 'HttpAction#SetCookie';
+
+export interface ISetCookieStepInit {
+  /**
+   * The name of the cookie
+   */
+  name: string;
+  /**
+   * The URL associated with the cookie. When not set it uses the request URL or the request URL of the last redirect.
+   */
+  url?: string;
+  /**
+   * The cookie expiration time. It can be a valid cookie date or a string representing a relative time to "now"
+   * like `4d`, `600s`, etc.
+   */
+  expires?: string;
+  /**
+   * Whether the cookie is host only
+   */
+  hostOnly?: boolean;
+  /**
+   * Whether the cookie is HTTP only
+   */
+  httpOnly?: boolean;
+  /**
+   * Whether the cookie is HTTPS only
+   */
+  secure?: boolean;
+  /**
+   * Whether the cookie is a session cookie
+   */
+  session?: boolean;
+  /**
+   * The SameSite parameter of the cookie.
+   * https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#creating_cookies
+   */
+  sameSite?: SameSiteValue;
+}
+
+/**
+ * A step that allows to set a cookie with the value returned by a previous step.
+ */
+export interface ISetCookieStep extends IHttpStep, ISetCookieStepInit {
+  kind: typeof SetCookieStepKind;
+}
+
+
+export class SetCookieStep extends HttpStep {
+  override kind = SetCookieStepKind;
+
+  /**
+   * The name of the cookie
+   */
+  name = '';
+
+  /**
+   * The URL associated with the cookie. 
+   * When not set it uses the request URL or the request URL of the last redirect.
+   */
+  url?: string;
+
+  /**
+   * The cookie expiration time. It can be a valid cookie date or a string representing a relative time to "now"
+   * like `4d`, `600s`, etc.
+   */
+  expires?: string;
+
+  /**
+   * Whether the cookie is host only
+   */
+  hostOnly?: boolean;
+
+  /**
+   * Whether the cookie is HTTP only
+   */
+  httpOnly?: boolean;
+
+  /**
+   * Whether the cookie is HTTPS only
+   */
+  secure?: boolean;
+
+  /**
+   * Whether the cookie is a session cookie
+   */
+  session?: boolean;
+
+  /**
+   * The SameSite parameter of the cookie.
+   * https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#creating_cookies
+   */
+  sameSite?: SameSiteValue;
+
+  /**
+   * Creates the step from values.
+   * @param name The name of the variable to set
+   */
+  constructor(name: string);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: ISetCookieStepInit);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(nameOrInit?: string | ISetCookieStepInit) {
+    super();
+    if (!nameOrInit) {
+      return;
+    }
+    if (typeof nameOrInit === 'object') {
+      const typed = nameOrInit as ISetCookieStepInit;
+      this.new({ ...typed, kind: SetCookieStepKind  });
+    } else if (typeof nameOrInit === 'string') {
+      this.new({
+        kind: SetCookieStepKind,
+        name: nameOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: ISetCookieStep): void {
+    super.new(init);
+    this.kind = SetCookieStepKind;
+    this.name = init.name;
+    if (init.url) {
+      this.url = init.url;
+    } else {
+      this.url = undefined;
+    }
+    if (init.expires) {
+      this.expires = init.expires;
+    } else {
+      this.expires = undefined;
+    }
+    if (typeof init.hostOnly === 'boolean') {
+      this.hostOnly = init.hostOnly;
+    } else {
+      this.hostOnly = undefined;
+    }
+    if (typeof init.httpOnly === 'boolean') {
+      this.httpOnly = init.httpOnly;
+    } else {
+      this.httpOnly = undefined;
+    }
+    if (typeof init.secure === 'boolean') {
+      this.secure = init.secure;
+    } else {
+      this.secure = undefined;
+    }
+    if (typeof init.session === 'boolean') {
+      this.session = init.session;
+    } else {
+      this.session = undefined;
+    }
+    if (typeof init.sameSite === 'boolean') {
+      this.sameSite = init.sameSite;
+    } else {
+      this.sameSite = undefined;
+    }
+  }
+
+  checkValidity(): boolean {
+    const { name } = this;
+    return !!name;
+  }
+
+  override toJSON(): ISetCookieStep {
+    const result: ISetCookieStep = {
+      ...super.toJSON(),
+      kind: SetCookieStepKind,
+      name: this.name,
+    };
+    if (this.url) {
+      result.url = this.url;
+    }
+    if (this.expires) {
+      result.expires = this.expires;
+    }
+    if (typeof this.hostOnly === 'boolean') {
+      result.hostOnly = this.hostOnly;
+    }
+    if (typeof this.httpOnly === 'boolean') {
+      result.httpOnly = this.httpOnly;
+    }
+    if (typeof this.secure === 'boolean') {
+      result.secure = this.secure;
+    }
+    if (typeof this.session === 'boolean') {
+      result.session = this.session;
+    }
+    if (typeof this.sameSite === 'boolean') {
+      result.sameSite = this.sameSite;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/data/SetDataStep.ts

@@ -0,0 +1,124 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const SetDataStepKind = 'HttpAction#SetData';
+
+/**
+ * Sets a manually defined value that can be passed to the next step.
+ */
+export interface ISetDataStep extends IHttpStep {
+  kind: typeof SetDataStepKind;
+  /**
+   * The value to return to the next step.
+   * 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;
+}
+
+export class SetDataStep extends HttpStep {
+  override kind = SetDataStepKind;
+
+  /**
+   * The value to return to the next step.
+   * This is always a string. Use the `dataType` to determine the correct data type.
+   */
+  value = '';
+
+  /**
+   * 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;
+
+  /**
+   * Creates the step from values.
+   * @param value The value this step sets.
+   * @param dataType The data type to use to read the value.
+   */
+  constructor(value: string, dataType?: string);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: ISetDataStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(valueOrInit?: string | ISetDataStep, dataType?: string) {
+    super();
+    if (!valueOrInit) {
+      return;
+    }
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as ISetDataStep;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: SetDataStepKind,
+        value: valueOrInit,
+        dataType,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: ISetDataStep): void {
+    super.new(init);
+    this.kind = SetDataStepKind;
+    this.value = init.value;
+    this.dataType = init.dataType;
+  }
+
+  checkValidity(): boolean {
+    const { value } = this;
+    return !!value;
+  }
+
+  override toJSON(): ISetDataStep {
+    const result: ISetDataStep = {
+      ...super.toJSON(),
+      kind: SetDataStepKind,
+      value: this.value,
+    };
+    if (this.dataType) {
+      result.dataType = this.dataType;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/data/SetVariableStep.ts

@@ -0,0 +1,82 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const SetVariableStepKind = 'HttpAction#SetVariable';
+
+/**
+ * A step that accepts an input from the previous step and sets a variable in the current environment
+ * with this value. If the value is `void`, `null`, or `undefined` then the variable is removed from the 
+ * environment.
+ * 
+ * All variables are strings.
+ */
+export interface ISetVariableStep extends IHttpStep {
+  kind: typeof SetVariableStepKind;
+  /**
+   * The name of the variable to set
+   */
+  name: string;
+}
+
+
+export class SetVariableStep extends HttpStep {
+  override kind = SetVariableStepKind;
+
+  /**
+   * The name of the variable to set
+   */
+  name = '';
+
+  /**
+   * Creates the step from values.
+   * @param name The name of the variable to set
+   */
+  constructor(name: string);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: ISetVariableStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(nameOrInit?: string | ISetVariableStep) {
+    super();
+    if (!nameOrInit) {
+      return;
+    }
+    if (typeof nameOrInit === 'object') {
+      const typed = nameOrInit as ISetVariableStep;
+      this.new(typed);
+    } else if (typeof nameOrInit === 'string') {
+      this.new({
+        kind: SetVariableStepKind,
+        name: nameOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: ISetVariableStep): void {
+    super.new(init);
+    this.kind = SetVariableStepKind;
+    this.name = init.name;
+  }
+
+  checkValidity(): boolean {
+    const { name } = this;
+    return !!name;
+  }
+
+  override toJSON(): ISetVariableStep {
+    const result: ISetVariableStep = {
+      ...super.toJSON(),
+      kind: SetVariableStepKind,
+      name: this.name,
+    };
+    return result;
+  }
+}

package/src/models/http-actions/steps/transformation/AsLowerCaseStep.ts

@@ -0,0 +1,41 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const AsLowerCaseStepKind = 'HttpAction#AsLowerCase';
+
+/**
+ * Reads the input and returns a lower case value of it.
+ */
+export interface IAsLowerCaseStep extends IHttpStep {
+  kind: typeof AsLowerCaseStepKind;
+}
+
+/**
+ * Reads the input and returns a lower case value of it.
+ */
+export class AsLowerCaseStep extends HttpStep {
+  override kind = AsLowerCaseStepKind;
+
+  constructor(init?: IAsLowerCaseStep) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IAsLowerCaseStep): void {
+    super.new(init);
+    this.kind = AsLowerCaseStepKind;
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IAsLowerCaseStep {
+    const result: IAsLowerCaseStep = {
+      ...super.toJSON(),
+      kind: AsLowerCaseStepKind,
+    };
+    return result;
+  }
+}

package/src/models/http-actions/steps/transformation/AsNumberStep.ts

@@ -0,0 +1,41 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const AsNumberStepKind = 'HttpAction#AsNumber';
+
+/**
+ * Reads the input and returns is as a number.
+ */
+export interface IAsNumberStep extends IHttpStep {
+  kind: typeof AsNumberStepKind;
+}
+
+/**
+ * Reads the input and returns is as a number.
+ */
+export class AsNumberStep extends HttpStep {
+  override kind = AsNumberStepKind;
+
+  constructor(init?: IAsNumberStep) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IAsNumberStep): void {
+    super.new(init);
+    this.kind = AsNumberStepKind;
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IAsNumberStep {
+    const result: IAsNumberStep = {
+      ...super.toJSON(),
+      kind: AsNumberStepKind,
+    };
+    return result;
+  }
+}