@api-client/core 0.5.25 → 0.5.28

package/src/models/RequestConfig.ts

@@ -59,6 +59,12 @@ export interface IRequestBaseConfig {
    * Whether the processor should validate certificates.
    */
   validateCertificates?: boolean;
+
+  /**
+   * Optional signal from an `AbortController`.
+   * This is populated only when executing a request. This value is opaque for the data store.
+   */
+  signal?: AbortSignal;
 }
 
 /**
@@ -150,6 +156,12 @@ export class RequestConfig {
    */
   sentMessageLimit?: number;
 
+  /**
+   * Optional signal from an `AbortController`.
+   * This is populated only when executing a request. This value is opaque for the data store.
+   */
+  signal?: AbortSignal;
+
   static withDefaults(): RequestConfig {
     return new RequestConfig({
       kind: Kind,
@@ -209,7 +221,7 @@ export class RequestConfig {
   new(init: IRequestConfig): void {
     const { 
       enabled, followRedirects, ignoreSessionCookies, validateCertificates, defaultHeaders, timeout, hosts, variables,
-      defaultAccept, defaultUserAgent, proxy, proxyPassword, proxyUsername, sentMessageLimit,
+      defaultAccept, defaultUserAgent, proxy, proxyPassword, proxyUsername, sentMessageLimit, signal,
     } = init;
     this.kind = Kind;
     if (typeof enabled === 'boolean') {
@@ -282,6 +294,11 @@ export class RequestConfig {
     } else {
       this.sentMessageLimit = undefined;
     }
+    if (signal) {
+      this.signal = signal;
+    } else {
+      this.signal = undefined;
+    }
   }
 
   toJSON(): IRequestConfig {
@@ -310,6 +327,7 @@ export class RequestConfig {
     if (Array.isArray(this.variables)) {
       result.variables = this.variables.map(i => i.toJSON());
     }
+    // DO NOT put the `signal` here.
     return result;
   }
 }

package/src/runtime/http-engine/CoreEngine.ts

@@ -74,7 +74,7 @@ export class CoreEngine extends HttpEngine {
       } else {
         await this.connect();
       }
-      if (!this.socket) {
+      if (!this.socket || this.aborted) {
         return;
       }
       const message = await this.prepareMessage();

package/src/runtime/http-engine/HttpEngine.ts

@@ -191,6 +191,31 @@ export abstract class HttpEngine extends EventEmitter {
   protected mainRejecter?: (err: SerializableError) => void;
   [mainPromiseSymbol]?: Promise<IRequestLog>;
 
+  protected _signal?: AbortSignal;
+
+  /**
+   * The abort signal to set on this request.
+   * Aborts the request when the signal fires.
+   * @type {(AbortSignal | undefined)}
+   */
+  get signal(): AbortSignal | undefined {
+    return this._signal;
+  }
+
+  set signal(value: AbortSignal | undefined) {
+    const old = this._signal;
+    if (old === value) {
+      return;
+    }
+    this._signal = value;
+    if (old) {
+      old.removeEventListener('abort', this._abortHandler);
+    }
+    if (value) {
+      value.addEventListener('abort', this._abortHandler);
+    }
+  }
+
   constructor(request: IHttpRequest, opts: HttpEngineOptions = {}) {
     super();
     this.request = new HttpRequest({ ...request });
@@ -199,6 +224,11 @@ export abstract class HttpEngine extends EventEmitter {
     this.sentRequest = new SentRequest({ ...request, startTime: Date.now() });
     this.uri = this.readUrl(request.url);
     this.hostHeader = RequestUtils.getHostHeader(request.url);
+
+    this._abortHandler = this._abortHandler.bind(this);
+    if (opts.signal) {
+      this.signal = opts.signal;
+    }
   }
 
   /**
@@ -245,6 +275,15 @@ export abstract class HttpEngine extends EventEmitter {
     this.socket = undefined;
   }
 
+  /**
+   * Handler for the `abort` event on the `AbortSignal`.
+   */
+  protected _abortHandler(): void {
+    const e = new SerializableError('Request aborted', 3);
+    this._errorRequest(e);
+    this.abort();
+  }
+
   /**
    * Sends the request.
    */

package/src/runtime/node/InteropInterfaces.ts

@@ -118,4 +118,10 @@ export interface IProjectRunnerOptions {
    * When not set it does not read system variables.
    */
   variables?: boolean | string[] | Record<string, string>;
+
+  /**
+   * Optional signal from an `AbortController`.
+   * It aborts the execution when the ``abort` event is dispatched.
+   */
+  signal?: AbortSignal;
 }

package/src/runtime/node/ProjectParallelRunner.ts

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'url';
 import { HttpProject } from '../../models/HttpProject.js';
 import { IProjectExecutionLog, IProjectExecutionIteration } from '../reporters/Reporter.js';
 import { BaseRunner } from './BaseRunner.js';
+import { State } from './enums.js';
 import { IProjectParallelRunnerOptions, IProjectParallelWorkerOptions } from './InteropInterfaces.js'
 
 const numCPUs = cpus().length;
@@ -74,9 +75,13 @@ export class ProjectParallelRunner extends BaseRunner {
   constructor(project: HttpProject, opts: IProjectParallelRunnerOptions = {}) {
     super();
     this.project = project;
-    this.options = opts || {};
+    this.options = opts;
 
     this._exitHandler = this._exitHandler.bind(this);
+    this._abortHandler = this._abortHandler.bind(this);
+    if (opts.signal) {
+      this.signal = opts.signal;
+    }
   }
 
   execute(): Promise<IProjectExecutionLog> {
@@ -87,7 +92,70 @@ export class ProjectParallelRunner extends BaseRunner {
     });
   }
 
+  protected _state: State = State.Idle;
+
+  get state(): State {
+    return this._state;
+  }
+
+  protected _signal?: AbortSignal;
+
+  /**
+   * The abort signal to set on this request.
+   * Aborts the request when the signal fires.
+   * @type {(AbortSignal | undefined)}
+   */
+  get signal(): AbortSignal | undefined {
+    return this._signal;
+  }
+
+  set signal(value: AbortSignal | undefined) {
+    const old = this._signal;
+    if (old === value) {
+      return;
+    }
+    this._signal = value;
+    if (old) {
+      old.removeEventListener('abort', this._abortHandler);
+    }
+    if (value) {
+      value.addEventListener('abort', this._abortHandler);
+    }
+  }
+
+  /**
+   * Aborts the current run.
+   * The promise returned by the `execute()` method will reject if not yet resolved.
+   */
+  abort(): void {
+    this._state = State.Aborted;
+    const { workers } = this;
+    workers.forEach((info) => {
+      if (info.status !== 'error') {
+        try {
+          info.worker.destroy();
+        } catch (e) {
+          // ...
+        }
+        info.status = 'error';
+      }
+    });
+    if (this.mainRejecter) {
+      this.mainRejecter!(new Error(`The execution has been aborted.`));
+      this.mainRejecter = undefined;
+      this.mainResolver = undefined;
+    }
+  }
+
+  /**
+   * Handler for the `abort` event on the `AbortSignal`.
+   */
+  protected _abortHandler(): void {
+    this.abort();
+  }
+
   private _execute(): void {
+    this._state = State.Running as State;
     try {
       cluster.setupPrimary({
         exec: join(__dirname, 'ProjectRunnerWorker.js'),
@@ -105,6 +173,9 @@ export class ProjectParallelRunner extends BaseRunner {
     } catch (e) {
       const cause = e as Error;
       this.mainRejecter!(cause);
+      this.mainResolver = undefined
+      this.mainRejecter = undefined
+      this._state = State.Idle as State;
     }
   }
 
@@ -211,7 +282,10 @@ export class ProjectParallelRunner extends BaseRunner {
     this.endTime = Date.now();
     const report = await this.createReport();
     this.mainResolver(report);
+    this.mainResolver = undefined
+    this.mainRejecter = undefined
     cluster.off('exit', this._exitHandler);
+    this._state = State.Idle as State;
   }
 
   private setRunError(worker: Worker, message: IWorkerMessage): void {

package/src/runtime/node/ProjectRequestRunner.ts

@@ -14,6 +14,7 @@ import { VariablesProcessor } from '../variables/VariablesProcessor.js';
 import { RequestFactory } from './RequestFactory.js';
 import { EventTypes } from '../../events/EventTypes.js';
 import { ProjectRunnerOptions, ProjectRunnerRunOptions, RunResult } from './InteropInterfaces.js';
+import { State } from './enums.js';
 
 export interface ProjectRequestRunner {
   /**
@@ -62,6 +63,12 @@ export class ProjectRequestRunner extends EventEmitter {
    */
   protected variablesProcessor = new VariablesProcessor();
 
+  protected _state: State = State.Idle;
+
+  get state(): State {
+    return this._state;
+  }
+
   constructor(project: HttpProject, opts: ProjectRunnerOptions = {}) {
     super();
     this.project = project;
@@ -77,15 +84,25 @@ export class ProjectRequestRunner extends EventEmitter {
    * @returns A promise with the run result.
    */
   async run(options?: ProjectRunnerRunOptions): Promise<RunResult[]> {
+    this._state = State.Running as State;
     const { project } = this;
     const executed: RunResult[] = [];
     for (const request of project.requestIterator(options)) {
       const info = await this._runItem(request);
       executed.push(info);
     }
+    this._state = State.Idle;
     return executed;
   }
 
+  /**
+   * Aborts the current run.
+   * The promise returned by the `run()` method will reject if not yet resolved.
+   */
+  abort(): void {
+    this._state = State.Aborted;
+  }
+
   /**
    * Allows to iterate over project requests recursively and execute each request
    * in order. The generator yields the `RunResult` for the request.
@@ -101,13 +118,18 @@ export class ProjectRequestRunner extends EventEmitter {
    */
   async* [Symbol.asyncIterator](): AsyncGenerator<RunResult> {
     const { project } = this;
+    this._state = State.Running as State;
     for (const request of project.requestIterator({ recursive: true })) {
       const info = await this._runItem(request);
       yield info;
     }
+    this._state = State.Idle;
   }
 
   private async _runItem(request: ProjectRequest): Promise<RunResult> {
+    if (this._state === State.Aborted) {
+      throw new Error(`The execution has been aborted.`);
+    }
     const folder = request.getParent();
     const parent = folder || this.project;
     let variables: Record<string, string>;

package/src/runtime/node/ProjectRunner.ts

@@ -10,6 +10,7 @@ import { IProjectExecutionIteration, IProjectExecutionLog } from '../reporters/R
 import { pathExists, readJson } from '../../lib/fs/Fs.js';
 import { BaseRunner } from './BaseRunner.js';
 import { IProjectRunnerOptions } from './InteropInterfaces.js';
+import { State } from './enums.js';
 
 type ProjectParent = HttpProject | ProjectFolder;
 
@@ -127,11 +128,48 @@ export abstract class ProjectRunner extends BaseRunner {
    */
   noEmit = false;
 
+  /**
+   * When executing, this is the last user request runner.
+   */
+  protected _runner?: ProjectRequestRunner;
+
+  protected _state: State = State.Idle;
+
+  get state(): State {
+    return this._state;
+  }
+
+  protected _signal?: AbortSignal;
+
+  /**
+   * The abort signal to set on this request.
+   * Aborts the request when the signal fires.
+   * @type {(AbortSignal | undefined)}
+   */
+  get signal(): AbortSignal | undefined {
+    return this._signal;
+  }
+
+  set signal(value: AbortSignal | undefined) {
+    const old = this._signal;
+    if (old === value) {
+      return;
+    }
+    this._signal = value;
+    if (old) {
+      old.removeEventListener('abort', this._abortHandler);
+    }
+    if (value) {
+      value.addEventListener('abort', this._abortHandler);
+    }
+  }
+
   constructor() {
     super();
     this._requestHandler = this._requestHandler.bind(this);
     this._responseHandler = this._responseHandler.bind(this);
     this._errorHandler = this._errorHandler.bind(this);
+    this._abortHandler = this._abortHandler.bind(this);
   }
 
   /**
@@ -152,6 +190,9 @@ export abstract class ProjectRunner extends BaseRunner {
     }
     this.root = root;
     this.environment = await this.getEnvironment();
+    if (opts.signal) {
+      this.signal = opts.signal;
+    }
   }
 
   /**
@@ -160,6 +201,24 @@ export abstract class ProjectRunner extends BaseRunner {
    */
   abstract execute(): Promise<IProjectExecutionLog>;
 
+  /**
+   * Aborts the current run.
+   * The promise returned by the `execute()` method will reject if not yet resolved.
+   */
+  abort(): void {
+    this._state = State.Aborted;
+    if (this._runner) {
+      this._runner.abort();
+    }
+  }
+
+  /**
+   * Handler for the `abort` event on the `AbortSignal`.
+   */
+  protected _abortHandler(): void {
+    this.abort();
+  }
+
   /**
    * Creates the report of the execution.
    */
@@ -207,6 +266,9 @@ export abstract class ProjectRunner extends BaseRunner {
    * Runs the requests from the project as configured.
    */
   protected async executeIteration(): Promise<void> {
+    if (this._state === State.Aborted) {
+      throw new Error(`The execution has been aborted.`);
+    }
     const { environment, project, options, hasIterations, index, noEmit } = this;
     if (!options || !project) {
       throw new Error(`Run configure() first.`);
@@ -221,6 +283,7 @@ export abstract class ProjectRunner extends BaseRunner {
       eventTarget: this.target,
       variables: this.getSystemVariables(),
     });
+    this._runner = runner;
     
     runner.on('request', this._requestHandler);
     runner.on('response', this._responseHandler);

package/src/runtime/node/ProjectRunnerWorker.ts

@@ -7,6 +7,7 @@ import { IWorkerMessage } from './ProjectParallelRunner.js';
 import { IProjectParallelWorkerOptions } from './InteropInterfaces.js';
 import { sleep } from '../../lib/timers/Timers.js';
 import { ProjectRunner } from './ProjectRunner.js';
+import { State } from './enums.js';
 
 class ProjectExeWorker extends ProjectRunner {
   initialize(): void {
@@ -40,6 +41,7 @@ class ProjectExeWorker extends ProjectRunner {
     }
     function unhandledRejection(): void {}
     process.on('unhandledRejection', unhandledRejection);
+    this._state = State.Running as State;
     this.startTime = Date.now();
     while (this.remaining > 0) {
       this.remaining--;
@@ -54,6 +56,7 @@ class ProjectExeWorker extends ProjectRunner {
 
     const log = await this.createReport();
     process.send!({ cmd: 'result', data: log.iterations });
+    this._state = State.Idle as State;
     return log;
   }
 }

package/src/runtime/node/ProjectSerialRunner.ts

@@ -2,6 +2,7 @@ import { SerializableError } from '../../models/SerializableError.js';
 import { sleep } from '../../lib/timers/Timers.js';
 import { ProjectRunner } from './ProjectRunner.js';
 import { IProjectExecutionLog } from '../reporters/Reporter.js';
+import { State } from './enums.js';
 
 /**
  * Project runner that runs the requests in the project one-by-one.
@@ -15,7 +16,7 @@ export class ProjectSerialRunner extends ProjectRunner {
     if (!root) {
       throw new SerializableError(`The project runner is not configured.`, 'ECONFIGURE');
     }
-    
+    this._state = State.Running as State;
     this.startTime = Date.now();
     while (this.remaining > 0) {
       this.remaining--;
@@ -29,7 +30,7 @@ export class ProjectSerialRunner extends ProjectRunner {
         await sleep(0);
       }
     }
-
+    this._state = State.Idle as State;
     this.endTime = Date.now();
     return this.createReport();
   }

package/src/runtime/node/RequestFactory.ts

@@ -73,6 +73,13 @@ export class RequestFactory {
 
   logger?: Logger;
 
+  /**
+   * The abort signal to set on this request.
+   * Aborts the request when the signal fires.
+   * @type {(AbortSignal | undefined)}
+   */
+  signal?: AbortSignal;
+
   /**
    * Creates an instance from the IRequest object with setting the corresponding variables.
    * @param eventTarget The main events bus.
@@ -302,7 +309,7 @@ export class RequestFactory {
    * Creates a configuration options for the HTTP engine.
    */
   async prepareEngineConfig(): Promise<HttpEngineOptions> {
-    const { certificates, logger } = this;
+    const { certificates, logger, signal } = this;
     const auth = await this.readAuthorization();
     const config = await this.readConfig();
     const opts: HttpEngineOptions = {};
@@ -315,6 +322,9 @@ export class RequestFactory {
     if (logger) {
       opts.logger = logger;
     }
+    if (signal) {
+      opts.signal = signal;
+    }
     if (!config || config.enabled === false) {
       return opts;
     }

package/src/runtime/node/enums.ts

@@ -0,0 +1,8 @@
+/**
+ * The request execution state.
+ */
+export enum State {
+  Idle,
+  Running,
+  Aborted,
+}