@api-client/core 0.9.4 → 0.9.5

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

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

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

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

@@ -0,0 +1,86 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const RoundStepKind = 'HttpAction#Round';
+
+/**
+ * Formats the input as a number using fixed-point notation.
+ */
+export interface IRoundStep extends IHttpStep {
+  kind: typeof RoundStepKind;
+  /**
+   * The number of digits to appear after the decimal point; should be a value between 0 and 100, inclusive. 
+   * If this argument is omitted, it is treated as 0.
+   * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed.
+   */
+  precision?: number;
+}
+
+/**
+ * Formats the input as a number using fixed-point notation.
+ */
+export class RoundStep extends HttpStep {
+  override kind = RoundStepKind;
+
+  /**
+   * The number of digits to appear after the decimal point; should be a value between 0 and 100, inclusive. 
+   * If this argument is omitted, it is treated as 0.
+   * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed.
+   */
+  precision?: number;
+
+  /**
+   * Creates the step from values.
+   * @param precision The name of the variable to set
+   */
+  constructor(precision: number);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: IRoundStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(precisionOrInit?: number | IRoundStep) {
+    super();
+    if (typeof precisionOrInit === 'object') {
+      const typed = precisionOrInit as IRoundStep;
+      this.new(typed);
+    } else if (typeof precisionOrInit === 'number') {
+      this.new({
+        kind: RoundStepKind,
+        precision: precisionOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IRoundStep): void {
+    super.new(init);
+    this.kind = RoundStepKind;
+    if (typeof init.precision === 'number') {
+      this.precision = init.precision;
+    } else {
+      this.precision = undefined;
+    }
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IRoundStep {
+    const result: IRoundStep = {
+      ...super.toJSON(),
+      kind: RoundStepKind,
+    };
+    if (typeof this.precision === 'number') {
+      result.precision = this.precision;
+    }
+    return result;
+  }
+}

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

@@ -0,0 +1,93 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const SubstringStepKind = 'HttpAction#Substring';
+
+/**
+ * Returns the part of the string from the start index up to and excluding the end index, or to the end of the string if no end index is supplied.
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring
+ */
+export interface ISubstringStep extends IHttpStep {
+  kind: typeof SubstringStepKind;
+
+  /**
+   * The index of the first character to include in the returned substring.
+   */
+  start?: number;
+
+  /**
+   * The index of the first character to exclude from the returned substring.
+   */
+  end?: number;
+}
+
+/**
+ * Returns the part of the string from the start index up to and excluding the end index, or to the end of the string if no end index is supplied.
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring
+ */
+export class SubstringStep extends HttpStep {
+  override kind = SubstringStepKind;
+
+  /**
+   * The index of the first character to include in the returned substring.
+   */
+  start?: number;
+
+  /**
+   * The index of the first character to exclude from the returned substring.
+   */
+  end?: number;
+
+  constructor(start: number, end?: number);
+
+  constructor(init: ISubstringStep);
+
+  constructor();
+
+  constructor(startOrInit?: number | ISubstringStep, end?: number) {
+    super();
+    if (typeof startOrInit === 'object') {
+      const typed = startOrInit as ISubstringStep;
+      this.new(typed);
+    } else if (typeof startOrInit === 'number') {
+      this.new({
+        kind: SubstringStepKind,
+        start: startOrInit,
+        end,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: ISubstringStep): void {
+    super.new(init);
+    this.kind = SubstringStepKind;
+    if (typeof init.start === 'number') {
+      this.start = init.start;
+    } else {
+      this.start = undefined;
+    }
+    if (typeof init.end === 'number') {
+      this.end = init.end;
+    } else {
+      this.end = undefined;
+    }
+  }
+  
+  checkValidity(): boolean {
+    return typeof this.start === 'number';
+  }
+
+  override toJSON(): ISubstringStep {
+    const result: ISubstringStep = {
+      ...super.toJSON(),
+      kind: SubstringStepKind,
+    };
+    if (typeof this.start === 'number') {
+      result.start = this.start;
+    }
+    if (typeof this.end === 'number') {
+      result.end = this.end;
+    }
+    return result;
+  }
+}

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

@@ -0,0 +1,43 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const TrimStepKind = 'HttpAction#Trim';
+
+/**
+ * Reads the input and trims it.
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim.
+ */
+export interface ITrimStep extends IHttpStep {
+  kind: typeof TrimStepKind;
+}
+
+/**
+ * Reads the input and trims it.
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim.
+ */
+export class TrimStep extends HttpStep {
+  override kind = TrimStepKind;
+
+  constructor(init?: ITrimStep) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: ITrimStep): void {
+    super.new(init);
+    this.kind = TrimStepKind;
+  }
+  
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): ITrimStep {
+    const result: ITrimStep = {
+      ...super.toJSON(),
+      kind: TrimStepKind,
+    };
+    return result;
+  }
+}

package/src/proxy/RequestProxy.ts

@@ -3,11 +3,12 @@ import { IRequestAuthorization } from '../models/RequestAuthorization.js';
 import { IRequestConfig } from '../models/RequestConfig.js';
 import Proxy, { IProxyResult } from "./Proxy.js";
 import { HttpCertificate } from '../models/ClientCertificate.js';
-import { IHttpActionFlow } from '../models/http-actions/HttpActions.js';
+import { IHttpFlow } from '../models/http-actions/HttpFlows.js';
 import { ApiError } from '../runtime/store/Errors.js';
 import { DummyLogger } from '../lib/logging/DummyLogger.js';
 import { HttpRequestRunner } from '../runtime/http-runner/HttpRequestRunner.js';
 import { IRequestLog } from "../models/RequestLog.js";
+import { IHttpAssertion } from '../models/http-actions/HttpAssertion.js';
 
 export interface IRequestProxyInit {
   kind: typeof HttpRequestKind;
@@ -34,7 +35,11 @@ export interface IRequestProxyInit {
   /**
    * The request flows to execute with the request.
    */
-  flows?: IHttpActionFlow[];
+  flows?: IHttpFlow[];
+  /**
+   * Assertions to execute with the request.
+   */
+  assertions?: IHttpAssertion[];
 }
 
 /**
@@ -66,7 +71,7 @@ export default class RequestProxy extends Proxy {
 
   async execute(): Promise<IProxyResult<IRequestLog>> {
     const data = this.init as IRequestProxyInit;
-    const { request, authorization, certificate, config={}, variables={}, flows } = data;
+    const { request, authorization, certificate, config={}, variables={}, flows, assertions } = data;
     const factory = new HttpRequestRunner();
     factory.variables = variables;
     factory.logger = new DummyLogger();
@@ -77,6 +82,9 @@ export default class RequestProxy extends Proxy {
     if (Array.isArray(flows) && flows.length) {
       factory.flows = flows;
     }
+    if (Array.isArray(assertions) && assertions.length) {
+      factory.assertions = assertions;
+    }
     if (certificate) {
       factory.certificates = [certificate];
     }