@api-client/core 0.9.4 → 0.9.5

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

@@ -0,0 +1,87 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const LessThanAssertionKind = 'HttpAction#LessThanAssertion';
+
+/**
+ * An assertion that makes sure the input value is less [or equal] to the set value.
+ */
+export interface ILessThanAssertion extends IHttpStep {
+  kind: typeof LessThanAssertionKind;
+
+  /**
+   * 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 less [or equal] to the set value.
+ */
+export class LessThanAssertion extends HttpStep {
+  override kind = LessThanAssertionKind;
+
+  /**
+   * 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: ILessThanAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: ILessThanAssertion | number, equal?: boolean) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as ILessThanAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'number') {
+      this.new({
+        kind: LessThanAssertionKind,
+        value: valueOrInit,
+        equal,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: ILessThanAssertion): void {
+    super.new(init);
+    this.kind = LessThanAssertionKind;
+    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(): ILessThanAssertion {
+    const result: ILessThanAssertion = {
+      ...super.toJSON(),
+      kind: LessThanAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    if (typeof this.equal === 'boolean') {
+      result.equal = this.equal;
+    }
+    return result;
+  }
+}

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

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

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

@@ -0,0 +1,85 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const MatchesSchemaAssertionKind = 'HttpAction#MatchesSchemaAssertion';
+
+/**
+ * An assertion that makes sure the input matches a JSON schema. The input has to be a valid JSON string, object, or an array.
+ */
+export interface IMatchesSchemaAssertion extends IHttpStep {
+  kind: typeof MatchesSchemaAssertionKind;
+
+  /**
+   * The application internal reference to the schema stored in a store.
+   */
+  ref?: string;
+
+  /**
+   * When set it ignores the `ref` and uses this JSON schema to validate the input against.
+   */
+  schema?: unknown;
+}
+
+/**
+ * An assertion that makes sure the input matches a JSON schema. The input has to be a valid JSON string, object, or an array.
+ */
+export class MatchesSchemaAssertion extends HttpStep {
+  override kind = MatchesSchemaAssertionKind;
+
+  /**
+   * The application internal reference to the schema stored in a store.
+   */
+  ref?: string;
+
+  /**
+   * When set it ignores the `ref` and uses this JSON schema to validate the input against.
+   */
+  schema?: unknown;
+
+  static fromRef(ref: string): MatchesSchemaAssertion {
+    return new MatchesSchemaAssertion({
+      kind: MatchesSchemaAssertionKind,
+      enabled: true,
+      ref,
+    });
+  }
+
+  static fromSchema(schema: unknown): MatchesSchemaAssertion {
+    return new MatchesSchemaAssertion({
+      kind: MatchesSchemaAssertionKind,
+      enabled: true,
+      schema,
+    });
+  }
+
+  constructor(init?: IMatchesSchemaAssertion) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IMatchesSchemaAssertion): void {
+    super.new(init);
+    this.kind = MatchesSchemaAssertionKind;
+    this.ref = init.ref;
+    this.schema = init.schema;
+  }
+
+  checkValidity(): boolean {
+    return !!this.schema || !!this.ref;
+  }
+
+  override toJSON(): IMatchesSchemaAssertion {
+    const result: IMatchesSchemaAssertion = {
+      ...super.toJSON(),
+      kind: MatchesSchemaAssertionKind,
+    };
+    if (this.ref) {
+      result.ref = this.ref;
+    }
+    if (this.schema) {
+      result.schema = this.schema;
+    }
+    return result;
+  }
+}

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

@@ -0,0 +1,130 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const NotEqualAssertionKind = 'HttpAction#NotEqualAssertion';
+
+/**
+ * An assertion that makes sure the input value is not [strict] equal to the set value.
+ */
+export interface INotEqualAssertion extends IHttpStep {
+  kind: typeof NotEqualAssertionKind;
+
+  /**
+   * 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 not [strict] equal to the set value.
+ */
+export class NotEqualAssertion extends HttpStep {
+  override kind = NotEqualAssertionKind;
+
+  /**
+   * 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: INotEqualAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: INotEqualAssertion | string, strict?: boolean, dataType?: string) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as INotEqualAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: NotEqualAssertionKind,
+        value: valueOrInit,
+        dataType,
+        strict,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: INotEqualAssertion): void {
+    super.new(init);
+    this.kind = NotEqualAssertionKind;
+    this.value = init.value;
+    this.dataType = init.dataType;
+    this.strict = init.strict;
+  }
+
+  checkValidity(): boolean {
+    return !!this.value;
+  }
+
+  override toJSON(): INotEqualAssertion {
+    const result: INotEqualAssertion = {
+      ...super.toJSON(),
+      kind: NotEqualAssertionKind,
+    };
+    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/NotIncludesAssertion.ts

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

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

@@ -0,0 +1,41 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const NotOkAssertionKind = 'HttpAction#NotOkAssertion';
+
+/**
+ * An assertion that makes sure the input has a truly value.
+ */
+export interface INotOkAssertion extends IHttpStep {
+  kind: typeof NotOkAssertionKind;
+}
+
+/**
+ * An assertion that makes sure the input has a truly value.
+ */
+export class NotOkAssertion extends HttpStep {
+  override kind = NotOkAssertionKind;
+
+  constructor(init?: INotOkAssertion) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: INotOkAssertion): void {
+    super.new(init);
+    this.kind = NotOkAssertionKind;
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): INotOkAssertion {
+    const result: INotOkAssertion = {
+      ...super.toJSON(),
+      kind: NotOkAssertionKind,
+    };
+    return result;
+  }
+}

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

@@ -0,0 +1,69 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+import { ToBeTypes } from "./ToBeAssertion.js";
+
+export const NotToBeAssertionKind = 'HttpAction#NotToBeAssertion';
+
+/**
+ * An assertion that makes sure the input is not of a specific type (string, number, boolean, object, array).
+ */
+export interface INotToBeAssertion extends IHttpStep {
+  kind: typeof NotToBeAssertionKind;
+
+  /**
+   * The type to expect.
+   */
+  value?: ToBeTypes;
+}
+
+/**
+ * An assertion that makes sure the input is not of a specific type (string, number, boolean, object, array).
+ */
+export class NotToBeAssertion extends HttpStep {
+  override kind = NotToBeAssertionKind;
+
+  /**
+   * The type to expect.
+   */
+  value?: ToBeTypes;
+
+  constructor(value: ToBeTypes);
+
+  constructor(init: INotToBeAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: INotToBeAssertion | ToBeTypes) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as INotToBeAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: NotToBeAssertionKind,
+        value: valueOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: INotToBeAssertion): void {
+    super.new(init);
+    this.kind = NotToBeAssertionKind;
+    this.value = init.value;
+  }
+
+  checkValidity(): boolean {
+    return !!this.value;
+  }
+
+  override toJSON(): INotToBeAssertion {
+    const result: INotToBeAssertion = {
+      ...super.toJSON(),
+      kind: NotToBeAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    return result;
+  }
+}

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

@@ -0,0 +1,41 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const OkAssertionKind = 'HttpAction#OkAssertion';
+
+/**
+ * An assertion that makes sure the input has a truly value.
+ */
+export interface IOkAssertion extends IHttpStep {
+  kind: typeof OkAssertionKind;
+}
+
+/**
+ * An assertion that makes sure the input has a truly value.
+ */
+export class OkAssertion extends HttpStep {
+  override kind = OkAssertionKind;
+
+  constructor(init?: IOkAssertion) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IOkAssertion): void {
+    super.new(init);
+    this.kind = OkAssertionKind;
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IOkAssertion {
+    const result: IOkAssertion = {
+      ...super.toJSON(),
+      kind: OkAssertionKind,
+    };
+    return result;
+  }
+}

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

@@ -0,0 +1,76 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const ToBeAssertionKind = 'HttpAction#ToBeAssertion';
+
+export enum ToBeTypes {
+  string = 'string',
+  number = 'number',
+  boolean = 'boolean',
+  object = 'object',
+  array = 'array',
+}
+
+/**
+ * An assertion that makes sure the input is of a specific type (string, number, boolean, object, array).
+ */
+export interface IToBeAssertion extends IHttpStep {
+  kind: typeof ToBeAssertionKind;
+
+  /**
+   * The type to expect.
+   */
+  value?: ToBeTypes;
+}
+
+/**
+ * An assertion that makes sure the input is of a specific type (string, number, boolean, object, array).
+ */
+export class ToBeAssertion extends HttpStep {
+  override kind = ToBeAssertionKind;
+
+  /**
+   * The type to expect.
+   */
+  value?: ToBeTypes;
+
+  constructor(value: ToBeTypes);
+
+  constructor(init: IToBeAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: IToBeAssertion | ToBeTypes) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as IToBeAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: ToBeAssertionKind,
+        value: valueOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IToBeAssertion): void {
+    super.new(init);
+    this.kind = ToBeAssertionKind;
+    this.value = init.value;
+  }
+
+  checkValidity(): boolean {
+    return !!this.value;
+  }
+
+  override toJSON(): IToBeAssertion {
+    const result: IToBeAssertion = {
+      ...super.toJSON(),
+      kind: ToBeAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    return result;
+  }
+}