@api-client/core 0.9.4 → 0.9.5

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

@@ -0,0 +1,102 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const DeleteCookieStepKind = 'HttpAction#DeleteCookie';
+
+/**
+ * A step allowing to delete a cookie for the given configuration.
+ * This step does not require an input.
+ */
+export interface IDeleteCookieStep extends IHttpStep {
+  kind: typeof DeleteCookieStepKind;
+  /**
+   * The URL associated with the cookie. When not set it uses the request URL or the request URL of the last redirect.
+   */
+  url?: string;
+  /**
+   * Name of the cookie to remove.
+   * When not set it removes all cookies for the URL.
+   */
+  name?: string;
+}
+
+export class DeleteCookieStep extends HttpStep {
+  override kind = DeleteCookieStepKind;
+
+  /**
+   * The URL associated with the cookie. When not set it uses the request URL or the request URL of the last redirect.
+   */
+  url?: string;
+  
+  /**
+   * Name of the cookie to remove.
+   * When not set it removes all cookies for the URL.
+   */
+  name?: string;
+
+  static byName(name: string): DeleteCookieStep {
+    return new DeleteCookieStep({
+      kind: DeleteCookieStepKind,
+      enabled: true,
+      name,
+    });
+  }
+
+  static byUrl(url: string): DeleteCookieStep {
+    return new DeleteCookieStep({
+      kind: DeleteCookieStepKind,
+      enabled: true,
+      url,
+    });
+  }
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: IDeleteCookieStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(init?: IDeleteCookieStep) {
+    super();
+    if (init) {
+      this.new(init);
+    }
+  }
+
+  override new(init: IDeleteCookieStep): void {
+    super.new(init);
+    this.kind = DeleteCookieStepKind;
+    if (init.url) {
+      this.url = init.url;
+    } else {
+      this.url = undefined;
+    }
+    if (init.name) {
+      this.name = init.name;
+    } else {
+      this.name = undefined;
+    }
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IDeleteCookieStep {
+    const result: IDeleteCookieStep = {
+      ...super.toJSON(),
+      kind: DeleteCookieStepKind,
+    };
+    if (this.url) {
+      result.url = this.url;
+    }
+    if (this.name) {
+      result.name = this.name;
+    }
+    return result;
+  }
+}

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

@@ -0,0 +1,103 @@
+import { FlowRequestDataEnum, FlowResponseDataEnum, FlowSourceEnum } from "../../HttpFlows";
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const ReadDataSourceStepKind = 'HttpAction#ReadDataSource';
+
+/**
+ * A step similar to `ReadDataStep` but it does not search for a value by the path 
+ * but returns the whole part of the request / response data (like status code, 
+ * status message, response headers, response body, request body, etc)
+ */
+export interface IReadDataSourceStep extends IHttpStep {
+  /**
+   * The source of the data.
+   */
+  source?: FlowSourceEnum;
+
+  /**
+   * The data to read.
+   */
+  data?: FlowRequestDataEnum | FlowResponseDataEnum;
+}
+
+/**
+ * A step similar to `ReadDataStep` but it does not search for a value by the path 
+ * but returns the whole part of the request / response data (like status code, 
+ * status message, response headers, response body, request body, etc)
+ */
+export class ReadDataSourceStep extends HttpStep {
+  override kind = ReadDataSourceStepKind;
+
+  /**
+   * The source of the data.
+   */
+  source?: FlowSourceEnum;
+
+  /**
+   * The data to read.
+   */
+  data?: FlowRequestDataEnum | FlowResponseDataEnum;
+
+  /**
+   * 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, data: FlowRequestDataEnum | FlowResponseDataEnum);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: IReadDataSourceStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(sourceOrInit?: FlowSourceEnum | IReadDataSourceStep, data?: FlowRequestDataEnum | FlowResponseDataEnum) {
+    super();
+    if (!sourceOrInit) {
+      return;
+    }
+    if (typeof sourceOrInit === 'object') {
+      const typed = sourceOrInit as IReadDataSourceStep;
+      this.new(typed);
+    } else if (typeof sourceOrInit === 'string') {
+      this.new({
+        kind: ReadDataSourceStepKind,
+        source: sourceOrInit,
+        data,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IReadDataSourceStep): void {
+    super.new(init);
+    this.kind = ReadDataSourceStepKind;
+    this.source = init.source;
+    this.data = init.data;
+  }
+
+  checkValidity(): boolean {
+    const { source, data } = this;
+    return !!source && !!data;
+  }
+
+  override toJSON(): IReadDataSourceStep {
+    const result: IReadDataSourceStep = {
+      ...super.toJSON(),
+      kind: ReadDataSourceStepKind,
+    };
+    if (this.source) {
+      result.source = this.source;
+    }
+    if (this.data) {
+      result.data = this.data;
+    }
+    return result;
+  }
+}

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;
+  }
+}